ts-codemod-lib 3.3.0 → 3.3.1

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

@@ -1,873 +1,1002 @@
-import { ISet, Arr, pipe, match, mapNullable, isString } from 'ts-data-forge';
+import { Arr, ISet, isString, mapNullable, match, pipe, } 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';
-import { unwrapReadonlyTypeArgText } from '../functions/unwrap-readonly.mjs';
-import { wrapWithParentheses } from '../functions/wrap-with-parentheses.mjs';
-import { replaceNodeWithDebugPrint } from '../utils/replace-with-debug.mjs';
-import { invalidDeepReadonlyTypeName } from './readonly-transformer-helpers/constants.mjs';
-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 convertToReadonlyTransformer = (options) => {
-  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,
-    recordStyle: options?.recordStyle ?? "ReadonlyRecord",
-    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);
-      }
-    }
-  };
+import { hasDisableNextLineComment, isAtomicTypeNode, isConditionalTypeDistributionGuard, isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, removeParentheses, shouldAvoidParenthesesForReadonly, unwrapReadonlyTypeArgText, wrapWithParentheses, } from '../functions/index.mjs';
+import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
+import { groupUnionIntersectionTypes, invalidDeepReadonlyTypeName, nextReadonlyContext, } from './readonly-transformer-helpers/index.mjs';
+const TRANSFORMER_NAME = 'convert-to-readonly';
+export 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,
+        recordStyle: options?.recordStyle ?? 'ReadonlyRecord',
+        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;
-  }
-  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);
-  }
-};
-const transformTypeReferenceNode = (node, readonlyContext, options) => {
-  const typeNameStr = node.getTypeName().getText();
-  const typeArguments = node.getTypeArguments();
-  if (typeNameStr === "Array" || typeNameStr === "ReadonlyArray") {
-    if (!Arr.isFixedLengthArray(1, typeArguments)) {
-      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.isFixedLengthArray(1, typeArguments)) {
-      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.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Map.`
-      );
+    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;
     }
-    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 === "Record") {
-    if (!Arr.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Record.`
-      );
+
+    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;
+        }
+
+
+
+
+
+
+
+
     }
-    const nextReadonlyContextValue = nextReadonlyContext({
-      currentReadonlyContext: readonlyContext,
-      nextReadonlyContextType: "none",
-      indexedAccessDepthChange: "keep"
-    });
-    for (const t of typeArguments) {
-      transformNode(t, nextReadonlyContextValue, options);
-    }
-    if (readonlyContext.type === "none" && readonlyContext.indexedAccessDepth === 0) {
-      const [K, V] = node.getTypeArguments();
-      options.replaceNode(
-        node,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        readonlyRecordText(K.getFullText(), V.getFullText(), options)
-      );
-    }
-    return;
-  }
-  if (typeNameStr === "ReadonlyRecord") {
-    if (!Arr.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for ReadonlyRecord.`
-      );
+
+
+    if ((node.isKind(tsm.SyntaxKind.FunctionDeclaration) ||
+        node.isKind(tsm.SyntaxKind.FunctionExpression)) &&
+        options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
+        return;
     }
-    const nextReadonlyContextValue = nextReadonlyContext({
-      currentReadonlyContext: readonlyContext,
-      nextReadonlyContextType: "none",
-      indexedAccessDepthChange: "keep"
-    });
-    for (const t of typeArguments) {
-      transformNode(t, nextReadonlyContextValue, options);
-    }
-    const [K, V] = node.getTypeArguments();
-    const bareRecordText = (
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      `Record<${K.getFullText()}, ${V.getFullText()}>`
-    );
-    if (readonlyContext.type === "Readonly" && readonlyContext.indexedAccessDepth === 0) {
-      options.replaceNode(node, bareRecordText);
-      return;
-    }
-    if (options.recordStyle === "Readonly<Record>") {
-      if (readonlyContext.type !== "none" || readonlyContext.indexedAccessDepth > 0) {
-        options.replaceNode(node, bareRecordText);
+    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;
-      }
-      options.replaceNode(node, `Readonly<${bareRecordText}>`);
-      return;
-    }
-    return;
-  }
-  if (typeNameStr === "Readonly") {
-    if (!Arr.isFixedLengthArray(1, typeArguments)) {
-      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.TypeReference) && T.getTypeName().getText() === "Record") {
-      const recordTypeArguments = T.getTypeArguments();
-      if (Arr.isFixedLengthArray(2, recordTypeArguments)) {
-        options.replaceNode(
-          node,
-          readonlyRecordText(
-            recordTypeArguments[0].getFullText(),
-            recordTypeArguments[1].getFullText(),
-            options
-          )
-        );
+    }
+    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 (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.isFixedLengthArray(1, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Readonly.`
-      );
-    }
-    transformNode(
-      typeArguments[0],
-      nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        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);
     }
-  }
+    if (node.isKind(tsm.SyntaxKind.ParenthesizedType)) {
+
+        transformParenthesizedTypeNode(node, readonlyContext, options);
+        return;
+    }
+    for (const child of node.getChildren()) {
+        transformNode(child, initialReadonlyContext, options);
+    }
 };
-const readonlyRecordText = (keyText, valueText, options) => options.recordStyle === "ReadonlyRecord" ? `ReadonlyRecord<${keyText}, ${valueText}>` : `Readonly<Record<${keyText}, ${valueText}>>`;
-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)
-        );
-      }
-  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const transformTypeReferenceNode = (
+
+node, readonlyContext, options) => {
+    const typeNameStr = node.getTypeName().getText();
+    const typeArguments = node.getTypeArguments();
+
+    if (typeNameStr === 'Array' || typeNameStr === 'ReadonlyArray') {
+        if (!Arr.isFixedLengthArray(1, typeArguments)) {
+            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.isFixedLengthArray(1, typeArguments)) {
+            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.isFixedLengthArray(2, typeArguments)) {
+            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Map.`);
+        }
+        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, 
+
+        `ReadonlyMap<${K.getFullText()}, ${V.getFullText()}>`);
+        return;
+    }
+
+    if (typeNameStr === 'Record') {
+        if (!Arr.isFixedLengthArray(2, typeArguments)) {
+            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Record.`);
+        }
+        const nextReadonlyContextValue = nextReadonlyContext({
+            currentReadonlyContext: readonlyContext,
+            nextReadonlyContextType: 'none',
+            indexedAccessDepthChange: 'keep',
+        });
+
+        for (const t of typeArguments) {
+            transformNode(t, nextReadonlyContextValue, options);
+        }
+
+
+
+
+
+
+        if (readonlyContext.type === 'none' &&
+            readonlyContext.indexedAccessDepth === 0) {
+            const [K, V] = node.getTypeArguments();
+            options.replaceNode(node, 
+
+            readonlyRecordText(K.getFullText(), V.getFullText(), options));
+        }
+        return;
+    }
+
+    if (typeNameStr === 'ReadonlyRecord') {
+        if (!Arr.isFixedLengthArray(2, typeArguments)) {
+            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for ReadonlyRecord.`);
+        }
+        const nextReadonlyContextValue = nextReadonlyContext({
+            currentReadonlyContext: readonlyContext,
+            nextReadonlyContextType: 'none',
+            indexedAccessDepthChange: 'keep',
+        });
+
+        for (const t of typeArguments) {
+            transformNode(t, nextReadonlyContextValue, options);
+        }
+        const [K, V] = node.getTypeArguments();
+        const bareRecordText = 
+
+        `Record<${K.getFullText()}, ${V.getFullText()}>`;
+
+
+
+        if (readonlyContext.type === 'Readonly' &&
+            readonlyContext.indexedAccessDepth === 0) {
+            options.replaceNode(node, bareRecordText);
+            return;
+        }
+        if (options.recordStyle === 'Readonly<Record>') {
+
+
+
+
+
+            if (readonlyContext.type !== 'none' ||
+                readonlyContext.indexedAccessDepth > 0) {
+                options.replaceNode(node, bareRecordText);
+                return;
+            }
+            options.replaceNode(node, `Readonly<${bareRecordText}>`);
+            return;
+        }
+
+
+
+
+
+        return;
+    }
+
+    if (typeNameStr === 'Readonly') {
+        if (!Arr.isFixedLengthArray(1, typeArguments)) {
+            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.TypeReference) &&
+            T.getTypeName().getText() === 'Record') {
+            const recordTypeArguments = T.getTypeArguments();
+            if (Arr.isFixedLengthArray(2, recordTypeArguments)) {
+                options.replaceNode(node, readonlyRecordText(recordTypeArguments[0].getFullText(), recordTypeArguments[1].getFullText(), options));
+                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.isFixedLengthArray(1, typeArguments)) {
+            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Readonly.`);
+        }
+
+        transformNode(typeArguments[0], nextReadonlyContext({
+            currentReadonlyContext: readonlyContext,
+            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);
+        }
+    }
 };
-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)
-        );
-      }
-  }
+
+const readonlyRecordText = (keyText, valueText, options) => options.recordStyle === 'ReadonlyRecord'
+    ? `ReadonlyRecord<${keyText}, ${valueText}>`
+    : `Readonly<Record<${keyText}, ${valueText}>>`;
+
+const transformArrayTypeNode = (
+
+node, readonlyContext, options) => {
+
+    transformNode(node.getElementTypeNode(), nextReadonlyContext({
+        currentReadonlyContext: readonlyContext,
+        nextReadonlyContextType: 'none',
+        indexedAccessDepthChange: 'decr',
+    }), options);
+    switch (readonlyContext.type) {
+        case 'DeepReadonly':
+        case 'readonly':
+            return;
+
+        case 'Readonly':
+        case 'none':
+
+
+            if (readonlyContext.indexedAccessDepth === 0 &&
+                !isConditionalTypeDistributionGuard(node)) {
+                const readonlyText = `readonly ${node.getFullText()}`;
+                options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
+                    ? readonlyText
+                    : wrapWithParentheses(readonlyText));
+            }
+    }
 };
-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()}`
-    );
-  }
+
+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;
+
+        case 'Readonly':
+        case 'none':
+
+
+            if (readonlyContext.indexedAccessDepth === 0 &&
+                !isConditionalTypeDistributionGuard(node)) {
+                const readonlyText = `readonly ${node.getFullText()}`;
+                options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
+                    ? readonlyText
+                    : wrapWithParentheses(readonlyText));
+            }
+    }
 };
-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());
-      }
-  }
+
+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()}` );
+    }
 };
-const transformTypeLiteralNode = (node, readonlyContext, options) => {
-  if (options.ignoreEmptyObjectTypes && Arr.isEmpty(node.getMembers())) {
-    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()}>`);
-      }
-    }
-  }
+
+
+
+
+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) {
+
+        case 'DeepReadonly':
+            options.replaceNode(node, node.getTypeNode().getFullText());
+            return;
+        case 'Readonly':
+        case 'none':
+            if (readonlyContext.indexedAccessDepth > 0) {
+                options.replaceNode(node, node.getTypeNode().getFullText());
+            }
+    }
 };
-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 transformTypeLiteralNode = (
+
+node, readonlyContext, options) => {
+    if (options.ignoreEmptyObjectTypes && Arr.isEmpty(node.getMembers())) {
+        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()}>`);
+            }
+        }
+    }
 };
-const transformMappedTypeNode = (node, readonlyContext, options) => {
-  const typeNode = node.getTypeNode();
-  if (typeNode !== void 0) {
-    transformNode(
-      typeNode,
-      nextReadonlyContext({
+
+const transformIndexedAccessTypeNode = (
+
+node, readonlyContext, options) => {
+
+    transformNode(node.getObjectTypeNode(), nextReadonlyContext({
+        currentReadonlyContext: readonlyContext,
+        nextReadonlyContextType: 'none',
+        indexedAccessDepthChange: 'incr',
+    }), options);
+    transformNode(node.getIndexTypeNode() , nextReadonlyContext({
         currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: "none",
-        indexedAccessDepthChange: "decr"
-      }),
-      options
-    );
-  }
-  const questionTokenText = pipe(node.getQuestionToken()?.getText()).mapNullable(
-    (t) => t === "?" ? "?" : t === "-" ? "-?" : t === "+" ? "+?" : void 0
-  ).value ?? "";
-  const nameTypeText = pipe(node.getNameTypeNode()?.getFullText()).mapNullable(
-    (t) => ` as ${t.trim()}`
-  ).value;
-  const result = pipe(
-    // remove readonlyToken
-    `{ [${node.getTypeParameter().getFullText()}${nameTypeText ?? ""}]${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);
+        nextReadonlyContextType: 'Readonly',
+        indexedAccessDepthChange: 'decr',
+    }), 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 transformMappedTypeNode = (
+
+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 nameTypeText = pipe(node.getNameTypeNode()?.getFullText()).mapNullable((t) => ` as ${t.trim()}`).value;
+    const result = pipe(
+
+    `{ [${node.getTypeParameter().getFullText()}${nameTypeText ?? ''}]${questionTokenText}: ${node.getTypeNode()?.getFullText()} }`).map((mpt) => match(readonlyContext.type, {
+
+        DeepReadonly: mpt,
+        Readonly: mpt,
+        none: readonlyContext.indexedAccessDepth > 0 ? mpt : `Readonly<${mpt}>`,
+    })).value;
+    options.replaceNode(node, result);
 };
-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);
-    }
-  }
+
+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 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);
-  }
+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 !== undefined) {
+                    transformNode(type, initialReadonlyContext, options);
+                }
+                const initializer = mb.getInitializer();
+                if (initializer !== undefined) {
+                    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 !== undefined) {
+            transformNode(body, initialReadonlyContext, options);
+        }
+    }
 };
-const transformIntersectionTypeNode = (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 !== undefined) {
+        transformNode(type, initialReadonlyContext, options);
+    }
 };
-const transformUnionTypeNode = (node, readonlyContext, options) => {
-  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, "|");
+
+
+
+
+const transformIntersectionTypeNode = (
+
+node, readonlyContext, options) => {
+    transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '&');
 };
-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.isEmpty(n.getMembers());
-  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(isEmptyTypeLiteral);
-  const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === void 0 || Arr.isEmpty(nonEmptyTypeLiterals) ? [] : [
-    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 transformUnionTypeNode = (
+
+node, readonlyContext, options) => {
+    transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '|');
 };
-const unionToString = ({
-  types: typesRaw,
-  op,
-  wrapWithReadonly
-}) => {
-  const types = typesRaw.map((s) => s.trim());
-  return unionToStringImpl({ types, op, wrapWithReadonly });
+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.isEmpty(n.getMembers());
+    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(isEmptyTypeLiteral);
+    const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
+        ? []
+        : [
+            unionToString({
+                types: nonEmptyTypeLiterals.map((n) => isReadonlyTypeReferenceNode(n)
+                    ?
+                        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 !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
+            ? mapNullable(typeLiterals, (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition])
+            : undefined,
+        emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
+            ? mapNullable(typeLiterals, (a) => [
+                emptyTypeLiterals.map((n) => n.getFullText()),
+
+                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]);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    options.replaceNode(node, unionToString({ types: sorted, op: operator, wrapWithReadonly: false }));
 };
-const unionToStringImpl = ({
-  types,
-  op,
-  wrapWithReadonly
-}) => Arr.isEmpty(types) ? "never" : Arr.isFixedLengthArray(1, types) ? 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) || // 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());
-  }
+const unionToString = ({ types: typesRaw, op, wrapWithReadonly, }) => {
+
+
+
+
+
+
+    const types = typesRaw.map((s) => s.trim());
+    return unionToStringImpl({ types, op, wrapWithReadonly });
 };
-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);
-  }
+const unionToStringImpl = ({ types, op, wrapWithReadonly, }) => Arr.isEmpty(types)
+    ? 'never'
+    : Arr.isFixedLengthArray(1, types)
+        ? 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 (
+
+
+    T.isKind(tsm.SyntaxKind.TypeReference) ||
+
+
+        T.isKind(tsm.SyntaxKind.ArrayType) ||
+
+
+        T.isKind(tsm.SyntaxKind.TupleType) ||
+
+
+        isAtomicTypeNode(T) ||
+
+
+        T.isKind(tsm.SyntaxKind.TypeLiteral) ||
+
+
+
+
+
+
+
+
+
+
+        T.isKind(tsm.SyntaxKind.ParenthesizedType)) {
+        options.replaceNode(node, T.getFullText());
+    }
 };
-const transformPropertySignature = (node, readonlyModifier, readonlyContext, options) => {
-  if (readonlyModifier === "remove" || readonlyContext.type === "DeepReadonly") {
-    node.setIsReadonly(false);
-  } else {
-    node.setIsReadonly(true);
-  }
-  {
-    const type = node.getTypeNode();
-    if (type !== void 0) {
-      transformNode(type, readonlyContext, options);
-    }
-  }
+
+
+
+
+
+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);
+    }
 };
-const transformIndexSignatureDeclaration = (node, readonlyModifier, readonlyContext, options) => {
-  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-    options.debugPrint("skipped index signature by disable-next-line comment");
-    return;
-  }
-  if (readonlyModifier === "remove" || readonlyContext.type === "DeepReadonly") {
-    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 transformPropertySignature = (
+
+node, readonlyModifier, readonlyContext, options) => {
+    if (readonlyModifier === 'remove' ||
+        readonlyContext.type === 'DeepReadonly') {
+        node.setIsReadonly(false);
+    }
+    else {
+        node.setIsReadonly(true);
+    }
+    {
+        const type = node.getTypeNode();
+        if (type !== undefined) {
+            transformNode(type, readonlyContext, options);
+        }
+    }
 };
-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
-  );
+const transformIndexSignatureDeclaration = (
+
+node, readonlyModifier, readonlyContext, options) => {
+    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+        options.debugPrint('skipped index signature by disable-next-line comment');
+        return;
+    }
+    if (readonlyModifier === 'remove' ||
+        readonlyContext.type === 'DeepReadonly') {
+
+        node.toggleModifier('readonly', false);
+    }
+    else {
+        node.toggleModifier('readonly', true);
+
+    }
+    {
+        const key = node.getKeyTypeNode();
+        transformNode(key, readonlyContext, options);
+    }
+    {
+        const ret = node.getReturnTypeNode();
+        if (ret !== undefined) {
+            transformNode(ret, readonlyContext, options);
+        }
+    }
 };
+const checkIfPropertyNameShouldBeIgnored = (
+
+nameNode, options) => {
 
-export { convertToReadonlyTransformer };
-//# sourceMappingURL=convert-to-readonly.mjs.map
+
+    return (
+
+    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
+        pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
+
+        (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
+            pipe(nameNode.getLiteralValue()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
+
+        (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
+            pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(`#${p}`))).value) ||
+
+        (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));
+};
+//# sourceMappingURL=convert-to-readonly.mjs.map