ts-codemod-lib 4.0.0 → 4.1.0

package/src/functions/ast-transformers/convert-to-readonly.mts

@@ -49,6 +49,10 @@ import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'convert-to-readonly';
 
+const READONLY_RECORD_NAME = 'ReadonlyRecord';
+
+const READONLY_RECORD_MODULE = 'ts-type-forge';
+
 export const convertToReadonlyTransformer = (
   options?: ReadonlyTransformerOptions,
 ): TsMorphTransformer => {
@@ -92,6 +96,7 @@ export const convertToReadonlyTransformer = (
       options?.mutablePropertyPrefixes ?? DEFAULT_MUTABLE_PREFIXES,
     ),
     recordStyle: options?.recordStyle ?? 'ReadonlyRecord',
+    importStyle: options?.importStyle ?? 'named',
     debugPrint: options?.debug === true ? console.debug : () => {},
     replaceNode:
       options?.debug === true
@@ -102,8 +107,30 @@ export const convertToReadonlyTransformer = (
   return {
     name: TRANSFORMER_NAME,
     transform: (sourceAst) => {
+      const scope =
+        optionsInternal.recordStyle === 'ReadonlyRecord' &&
+        optionsInternal.importStyle === 'named'
+          ? readonlyRecordScope(sourceAst.compilerNode)
+          : 'in-scope';
+
+      // An import would turn a script into a module, and its declarations would
+      // stop being global (a `global.d.ts`); in a file whose top level declares
+      // the name as a value or a namespace, it could clash. Either gets the
+      // built-in style instead.
+      const mayImport =
+        scope === 'free' && tsm.ts.isExternalModule(sourceAst.compilerNode);
+
+      const fileOptions: ReadonlyTransformerOptionsInternal =
+        scope !== 'in-scope' && !mayImport
+          ? ({ ...optionsInternal, recordStyle: 'Readonly<Record>' } as const)
+          : optionsInternal;
+
       for (const node of sourceAst.getChildren()) {
-        transformNode(node, initialReadonlyContext, optionsInternal);
+        transformNode(node, initialReadonlyContext, fileOptions);
+      }
+
+      if (mayImport && referencesReadonlyRecord(sourceAst.compilerNode)) {
+        addReadonlyRecordImport(sourceAst);
       }
     },
   };
@@ -121,7 +148,7 @@ export type ReadonlyTransformerOptions = DeepReadonly<{
      */
     typeName?: string;
 
-    /**
+    /*
      * Whether to apply `DeepReadonly` aggressively or remove `DeepReadonly` as
      * possible.
      *
@@ -157,8 +184,8 @@ export type ReadonlyTransformerOptions = DeepReadonly<{
 
   /**
    * Prefixes of the names of variables, parameters (but for a constructor
-   * parameter property, which `mutablePropertyPrefixes` decides) and
-   * functions that are left mutable: their types are not made readonly.
+   * parameter property, which `mutablePropertyPrefixes` decides) and functions
+   * that are left mutable: their types are not made readonly.
    *
    * @default ['mut_']
    */
@@ -181,8 +208,8 @@ export type ReadonlyTransformerOptions = DeepReadonly<{
    * both `mut_` and `#mut_` cover `#mut_x`. Of a named tuple member with such a prefix, only the type
    * is kept; the tuple is still made `readonly`.
    *
-   * A type literal with a property, a method or an accessor of such a prefix
-   * is not wrapped with `Readonly<...>`, which would make that member readonly
+   * A type literal with a property, a method or an accessor of such a prefix is
+   * not wrapped with `Readonly<...>`, which would make that member readonly
    * too; its other members are marked `readonly` one by one instead, and a
    * `Readonly<...>` written around it is taken off. It is wrapped as before
    * when it also has a member that cannot be marked `readonly` by itself (a
@@ -201,9 +228,8 @@ export type ReadonlyTransformerOptions = DeepReadonly<{
    * - `"ReadonlyRecord"`: Uses the `ReadonlyRecord` type utility provided by
    *   `ts-type-forge` (as the `ts-type-forge/prefer-readonly-or-mutable-record`
    *   ESLint rule suggests). Occurrences of `Readonly<Record<K, V>>` are also
-   *   unified to `ReadonlyRecord<K, V>`. Note that no import statement is
-   *   added, so `ReadonlyRecord` has to be available in the transformed code
-   *   (e.g. globally via `ts-type-forge`'s `global.d.mts`).
+   *   unified to `ReadonlyRecord<K, V>`. How the name is brought into scope
+   *   is set by `importStyle`.
    * - `"Readonly<Record>"`: Uses only built-in utility types
    *   (`Readonly<Record<K, V>>`). Occurrences of `ReadonlyRecord<K, V>` are
    *   also unified to `Readonly<Record<K, V>>`.
@@ -215,6 +241,29 @@ export type ReadonlyTransformerOptions = DeepReadonly<{
    */
   recordStyle?: 'Readonly<Record>' | 'ReadonlyRecord';
 
+  /**
+   * How `ReadonlyRecord` is brought into scope with `recordStyle:
+   * "ReadonlyRecord"` (the same choice as the `importStyle` option of
+   * `eslint-plugin-ts-type-forge`).
+   *
+   * - `"named"`: When the transformer writes `ReadonlyRecord` into a file that
+   *   does not mention the name yet, it also imports it — `import type {
+   *   ReadonlyRecord } from 'ts-type-forge';`, merged into an existing named
+   *   import of `ts-type-forge` where there is one. A file that already
+   *   imports, declares or uses the name (as a global from
+   *   `ts-type-forge/global`) is left to resolve it as before. A script (a
+   *   file with no import or export), which an import would turn into a
+   *   module, and a file whose top level declares the name as a value only,
+   *   which an import could clash with, get `Readonly<Record<K, V>>` instead.
+   * - `"global"`: Imports are never touched, so `ReadonlyRecord` has to be in
+   *   scope already: globally via `ts-type-forge/global`, or by an import the
+   *   caller writes itself (as when transforming a file one statement at a
+   *   time, where each statement would otherwise get an import of its own).
+   *
+   * @default 'named'
+   */
+  importStyle?: 'global' | 'named';
+
   debug?: boolean;
 }>;
 
@@ -236,6 +285,8 @@ type ReadonlyTransformerOptionsInternal = Readonly<{
 
   recordStyle: 'Readonly<Record>' | 'ReadonlyRecord';
 
+  importStyle: 'global' | 'named';
+
   debugPrint: (...args: readonly unknown[]) => void;
   replaceNode: (node: tsm.Node, newNodeText: string) => void;
 }>;
@@ -245,6 +296,27 @@ const initialReadonlyContext: ReadonlyContext = {
   indexedAccessDepth: 0,
 } as const;
 
+/** Whether a type alias, interface or class name starts with a `mutableTypePrefixes` entry. */
+const hasMutableTypeName = (
+  name: string | undefined,
+  options: ReadonlyTransformerOptionsInternal,
+): boolean =>
+  name !== undefined &&
+  options.mutableTypePrefixes.some((p) => name.startsWith(p));
+
+/**
+ * A parameter property is a property of the class, as a `PropertyDeclaration`
+ * is; any other parameter is a variable.
+ */
+const mutablePrefixesOfParameter = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  param: tsm.ParameterDeclaration,
+  options: ReadonlyTransformerOptionsInternal,
+): ISet<string> =>
+  param.isParameterProperty()
+    ? options.mutablePropertyPrefixes
+    : options.mutableVariablePrefixes;
+
 const transformNode = (
   node: tsm.Node,
   readonlyContext: ReadonlyContext,
@@ -480,229 +552,705 @@ const transformNode = (
   }
 };
 
-//
-// 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<{ mut_x: X; y: Y }>) |-> { mut_x: X; readonly y: tr(Y) }` (see
- *   `isLeftUnwrapped`)
- * - `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)[]>`
- * - `tr(Record<K, V>) |-> Readonly<Record<tr(K), tr(V)>>` (or
- *   `ReadonlyRecord<tr(K), tr(V)>`, depending on the `recordStyle` option;
- *   `Readonly<Record<K, V>>`, `ReadonlyRecord<K, V>` and
- *   `Readonly<ReadonlyRecord<K, V>>` are unified to the same style)
+ * The names a top-level statement binds, and whether each can name a type (an
+ * import can).
  */
-const transformTypeReferenceNode = (
+const topLevelBindings = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.TypeReferenceNode,
-  readonlyContext: StrictExclude<
-    ReadonlyContext,
-    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
-  >,
-  options: ReadonlyTransformerOptionsInternal,
-): void => {
-  const typeNameStr = node.getTypeName().getText();
-
-  const typeArguments = node.getTypeArguments();
+  statement: tsm.ts.Statement,
+): readonly Readonly<{ name: string; isType: boolean }>[] => {
+  if (tsm.ts.isImportDeclaration(statement)) {
+    const clause = statement.importClause;
 
-  // Array<T> / ReadonlyArray<T> to readonly T[]
-  if (typeNameStr === 'Array' || typeNameStr === 'ReadonlyArray') {
-    if (!Arr.isFixedLengthArray(1, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for ${typeNameStr}.`,
-      );
-    }
+    const bindings = clause?.namedBindings;
 
-    // Recursive processing
-    transformNode(
-      typeArguments[0],
-      {
-        type: 'none',
-        indexedAccessDepth: readonlyContext.indexedAccessDepth,
-      },
-      options,
-    );
+    // A namespace import cannot name a type.
+    const namespaceImport =
+      bindings !== undefined && tsm.ts.isNamespaceImport(bindings)
+        ? ([{ name: bindings.name.text, isType: false }] as const)
+        : ([] as const);
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const T = node.getTypeArguments()[0]!;
+    const named =
+      bindings !== undefined && tsm.ts.isNamedImports(bindings)
+        ? bindings.elements.map((element) => ({
+            name: element.name.text,
+            isType: true,
+          }))
+        : ([] as const);
 
-    options.replaceNode(
-      node,
-      readonlyContext.type === 'DeepReadonly'
-        ? wrapWithParentheses(`${wrapWithParentheses(T.getFullText())}[]`)
-        : wrapWithParentheses(
-            `readonly ${wrapWithParentheses(T.getFullText())}[]`,
-          ),
-    );
+    const defaultImport =
+      clause?.name === undefined
+        ? ([] as const)
+        : ([{ name: clause.name.text, isType: true }] as const);
 
-    return;
+    return [...defaultImport, ...namespaceImport, ...named];
   }
 
-  // Set<T> to ReadonlySet<T>
-  if (typeNameStr === 'Set') {
-    if (!Arr.isFixedLengthArray(1, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Set.`,
-      );
-    }
-
-    // Recursive processing
-    transformNode(
-      typeArguments[0],
-      {
-        type: 'none',
-        indexedAccessDepth: readonlyContext.indexedAccessDepth,
-      },
-      options,
-    );
+  if (tsm.ts.isImportEqualsDeclaration(statement)) {
+    return [{ name: statement.name.text, isType: true }];
+  }
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const T = node.getTypeArguments()[0]!;
+  if (
+    tsm.ts.isTypeAliasDeclaration(statement) ||
+    tsm.ts.isInterfaceDeclaration(statement) ||
+    tsm.ts.isClassDeclaration(statement) ||
+    tsm.ts.isEnumDeclaration(statement)
+  ) {
+    return statement.name === undefined
+      ? []
+      : [{ name: statement.name.text, isType: true }];
+  }
 
-    options.replaceNode(node, `ReadonlySet<${T.getFullText()}>`);
+  if (
+    (tsm.ts.isFunctionDeclaration(statement) ||
+      tsm.ts.isModuleDeclaration(statement)) &&
+    statement.name !== undefined &&
+    tsm.ts.isIdentifier(statement.name)
+  ) {
+    return [{ name: statement.name.text, isType: false }];
+  }
 
-    return;
+  if (tsm.ts.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.flatMap((declaration) =>
+      tsm.ts.isIdentifier(declaration.name)
+        ? [{ name: declaration.name.text, isType: false }]
+        : [],
+    );
   }
 
-  // Map<T> to ReadonlyMap<T>
-  if (typeNameStr === 'Map') {
-    if (!Arr.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Map.`,
-      );
-    }
+  return [];
+};
 
-    const nextReadonlyContextValue = nextReadonlyContext({
-      currentReadonlyContext: readonlyContext,
-      nextReadonlyContextType: 'none',
-      indexedAccessDepthChange: 'keep',
-    });
+/**
+ * Whether the file has a type reference to `ReadonlyRecord` (an `extends` or
+ * `implements` clause included).
+ */
+const referencesReadonlyRecord = (node: tsm.ts.Node): boolean =>
+  (tsm.ts.isTypeReferenceNode(node) &&
+    tsm.ts.isIdentifier(node.typeName) &&
+    node.typeName.text === READONLY_RECORD_NAME) ||
+  (tsm.ts.isExpressionWithTypeArguments(node) &&
+    tsm.ts.isIdentifier(node.expression) &&
+    node.expression.text === READONLY_RECORD_NAME) ||
+  (tsm.ts.forEachChild(
+    node,
+    (child) => referencesReadonlyRecord(child) || undefined,
+  ) ??
+    false);
 
-    // Recursive processing
-    for (const t of typeArguments) {
-      transformNode(t, nextReadonlyContextValue, options);
-    }
+/**
+ * Whether `ReadonlyRecord` can be written in the file as it is, with
+ * `importStyle: "named"`:
+ *
+ * - `"in-scope"`: the top level imports it or declares it as a type, or the
+ *   file has a type reference to it, which without either relies on a global.
+ * - `"taken"`: the top level declares it as a value or a namespace only, which
+ *   an import of the name could clash with (an exported one does).
+ * - `"free"`: neither; it can be imported.
+ *
+ * A qualified name (`tf.ReadonlyRecord`), a property name, the original name of
+ * an aliased import (`ReadonlyRecord as RR`) and a declaration in an inner
+ * scope bind nothing at the top level, so they do not count.
+ */
+const readonlyRecordScope = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.ts.SourceFile,
+): 'free' | 'in-scope' | 'taken' => {
+  const topLevelNames = sourceFile.statements.flatMap(topLevelBindings);
+
+  return topLevelNames.some(
+    ({ name, isType }) => isType && name === READONLY_RECORD_NAME,
+  ) || referencesReadonlyRecord(sourceFile)
+    ? 'in-scope'
+    : topLevelNames.some(({ name }) => name === READONLY_RECORD_NAME)
+      ? 'taken'
+      : 'free';
+};
 
-    const [K, V] = node.getTypeArguments();
+/**
+ * `end`, moved past the comments that start on the same line after it: one such
+ * as `// eslint-disable-line` is about that line.
+ */
+const endOfLineComments = (text: string, end: number): number =>
+  tsm.ts.getTrailingCommentRanges(text, end)?.at(-1)?.end ?? end;
 
-    options.replaceNode(
-      node,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      `ReadonlyMap<${K!.getFullText()}, ${V!.getFullText()}>`,
-    );
+/**
+ * Where a new import goes in a file with no import and no directive prologue:
+ * before the first statement, and before the run of JSDoc and `//` comments
+ * right above it with no blank line in between (its documentation, an
+ * `eslint-disable-next-line`), which belong to it. A comment separated from it
+ * by a blank line, a `/* ... *\/` comment (a file-wide `eslint-disable`, a
+ * license), a `///` directive, a pragma (`@ts-nocheck`, `@jsxImportSource`),
+ * which TypeScript reads only above the first statement, and a shebang stay
+ * above the import.
+ */
+const newImportPosition = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+): number => {
+  const text = sourceFile.getFullText();
 
-    return;
+  const first = sourceFile.getStatements().at(0);
+
+  if (first === undefined) {
+    return text.length;
   }
 
-  // Record<K, V> to ReadonlyRecord<K, V> / Readonly<Record<K, V>>
-  if (typeNameStr === 'Record') {
-    if (!Arr.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for Record.`,
-      );
-    }
+  const comments =
+    tsm.ts.getLeadingCommentRanges(text, first.getFullStart()) ?? [];
 
-    const nextReadonlyContextValue = nextReadonlyContext({
-      currentReadonlyContext: readonlyContext,
-      nextReadonlyContextType: 'none',
-      indexedAccessDepthChange: 'keep',
-    });
+  let mut_position = first.getStart();
 
-    // Recursive processing
-    for (const t of typeArguments) {
-      transformNode(t, nextReadonlyContextValue, options);
-    }
+  for (const comment of comments.toReversed()) {
+    const commentText = text.slice(comment.pos, comment.end);
 
-    // The bare Record is kept as is in the following cases:
-    // - DeepReadonly<Record<K, V>> already applies readonly recursively.
-    // - Readonly<Record<K, V>> is unified to the configured record style by
-    //   the surrounding `Readonly` handler.
-    // - Record<K, V>[I] does not need readonly, just like
-    //   `Readonly<{ ... }>[I] -> { ... }[I]`.
     if (
-      readonlyContext.type === 'none' &&
-      readonlyContext.indexedAccessDepth === 0
+      /\n[^\S\n]*\n/u.test(text.slice(comment.end, mut_position)) ||
+      commentText.startsWith('///') ||
+      (commentText.startsWith('/*') && !commentText.startsWith('/**')) ||
+      /@(?:ts-nocheck|ts-check|jsx)/u.test(commentText)
     ) {
-      const [K, V] = node.getTypeArguments();
-
-      options.replaceNode(
-        node,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        readonlyRecordText(K!.getFullText(), V!.getFullText(), options),
-      );
+      break;
     }
 
-    return;
+    mut_position = comment.pos;
   }
 
-  // Unify ReadonlyRecord<K, V> to the configured record style
-  if (typeNameStr === 'ReadonlyRecord') {
-    if (!Arr.isFixedLengthArray(2, typeArguments)) {
-      throw new Error(
-        `Unexpected number of type arguments "${typeArguments.length}" for ReadonlyRecord.`,
-      );
-    }
+  return mut_position;
+};
 
-    const nextReadonlyContextValue = nextReadonlyContext({
-      currentReadonlyContext: readonlyContext,
-      nextReadonlyContextType: 'none',
-      indexedAccessDepthChange: 'keep',
-    });
+/** The leading `'use client';`-like statements of the file. */
+const directivePrologue = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+): readonly tsm.ts.Statement[] => {
+  const statements = sourceFile.compilerNode.statements;
+
+  const end = statements.findIndex(
+    (statement) =>
+      !(
+        tsm.ts.isExpressionStatement(statement) &&
+        tsm.ts.isStringLiteral(statement.expression)
+      ),
+  );
 
-    // Recursive processing
-    for (const t of typeArguments) {
-      transformNode(t, nextReadonlyContextValue, options);
-    }
+  return statements.slice(0, end === -1 ? statements.length : end);
+};
 
-    const [K, V] = node.getTypeArguments();
+const insertReadonlyRecordImport = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+  text: string,
+): void => {
+  const imports = sourceFile.getImportDeclarations();
 
-    const bareRecordText =
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      `Record<${K!.getFullText()}, ${V!.getFullText()}>` as const;
+  const hosts = imports.filter(
+    (decl) =>
+      decl.getModuleSpecifierValue() === READONLY_RECORD_MODULE &&
+      tsm.Node.isNamedImports(decl.getImportClause()?.getNamedBindings()),
+  );
 
-    // Readonly<ReadonlyRecord<K, V>> -> Readonly<Record<K, V>>
-    //   (the surrounding `Readonly` handler then unifies it to the configured
-    //   record style, so the bare Record never survives into the output)
-    if (
-      readonlyContext.type === 'Readonly' &&
-      readonlyContext.indexedAccessDepth === 0
-    ) {
-      options.replaceNode(node, bareRecordText);
+  const host = hosts.find((decl) => decl.isTypeOnly()) ?? hosts.at(0);
 
-      return;
-    }
+  if (host !== undefined) {
+    // `import type { ..., type X }` is an error: the declaration already makes
+    // every name type-only.
+    host.addNamedImport({
+      name: READONLY_RECORD_NAME,
+      isTypeOnly: !host.isTypeOnly(),
+    });
 
-    if (options.recordStyle === 'Readonly<Record>') {
-      // The ReadonlyRecord name is eliminated everywhere:
-      // - DeepReadonly<ReadonlyRecord<K, V>> -> DeepReadonly<Record<K, V>>
-      // - ReadonlyRecord<K, V>[I] -> Record<K, V>[I]
-      //   (readonly is unnecessary under indexed access, as with
-      //   Readonly<{ ... }>[I] -> { ... }[I])
-      if (
-        readonlyContext.type !== 'none' ||
-        readonlyContext.indexedAccessDepth > 0
-      ) {
-        options.replaceNode(node, bareRecordText);
+    return;
+  }
 
-        return;
-      }
+  // `import type`, not `import { type X }`, which `verbatimModuleSyntax` keeps
+  // as `import {} from 'ts-type-forge'`, a module with nothing to run.
+  const declaration =
+    `import type { ${READONLY_RECORD_NAME} } from '${READONLY_RECORD_MODULE}';` as const;
 
-      options.replaceNode(node, `Readonly<${bareRecordText}>`);
+  const anchorEnd =
+    imports.at(-1)?.getEnd() ?? directivePrologue(sourceFile).at(-1)?.end;
 
-      return;
-    }
+  if (anchorEnd === undefined) {
+    sourceFile.insertText(newImportPosition(sourceFile), `${declaration}\n\n`);
+  } else {
+    sourceFile.insertText(
+      endOfLineComments(text, anchorEnd),
+      `\n${declaration}`,
+    );
+  }
+};
 
-    // With `recordStyle: "ReadonlyRecord"`, ReadonlyRecord is already the
-    // configured style. It is deliberately kept even under DeepReadonly or an
+/**
+ * Imports `ReadonlyRecord` from `ts-type-forge`: into the braces of an existing
+ * import of the module where there is one, or else as a new declaration —
+ * after the last import, else after the directive prologue, else before the
+ * first statement and the comments attached to it (see
+ * {@link newImportPosition}). The line breaks follow the file's.
+ */
+const addReadonlyRecordImport = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+): void => {
+  const text = sourceFile.getFullText();
+
+  // ts-morph writes its line breaks as the project's setting says, so the
+  // setting follows the file's for the edit.
+  const { manipulationSettings } = sourceFile.getProject();
+
+  const newLineKind = manipulationSettings.getNewLineKind();
+
+  manipulationSettings.set({
+    newLineKind: text.includes('\r\n')
+      ? tsm.NewLineKind.CarriageReturnLineFeed
+      : tsm.NewLineKind.LineFeed,
+  });
+
+  try {
+    insertReadonlyRecordImport(sourceFile, text);
+  } finally {
+    manipulationSettings.set({ newLineKind });
+  }
+};
+
+//
+// Transformer implementation for each node type
+//
+
+/** Renders a readonly `Record<K, V>` in the configured record style. */
+const readonlyRecordText = (
+  keyText: string,
+  valueText: string,
+  options: ReadonlyTransformerOptionsInternal,
+): string =>
+  options.recordStyle === 'ReadonlyRecord'
+    ? (`ReadonlyRecord<${keyText}, ${valueText}>` as const)
+    : (`Readonly<Record<${keyText}, ${valueText}>>` as const);
+
+/**
+ * The comments in `[from, to)` of a source file, each followed by what keeps
+ * the next token off it, and nothing else in that range — no whitespace, and no
+ * token such as a separator or a parenthesis.
+ */
+const commentsBetween = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+  from: number,
+  to: number,
+): string => {
+  if (to <= from) {
+    return '';
+  }
+
+  const scanner = tsm.ts.createScanner(
+    tsm.ts.ScriptTarget.Latest,
+    false,
+    tsm.ts.LanguageVariant.Standard,
+    sourceFile.getFullText(),
+    undefined,
+    from,
+    to - from,
+  );
+
+  const mut_comments: string[] = [];
+
+  while (scanner.scan() !== tsm.ts.SyntaxKind.EndOfFileToken) {
+    const token = scanner.getToken();
+
+    // A line comment runs to the end of the line, so it takes one along.
+    const separator =
+      token === tsm.ts.SyntaxKind.SingleLineCommentTrivia
+        ? '\n'
+        : token === tsm.ts.SyntaxKind.MultiLineCommentTrivia
+          ? ' '
+          : undefined;
+
+    if (separator !== undefined) {
+      mut_comments.push(`${scanner.getTokenText()}${separator}`);
+    }
+  }
+
+  return mut_comments.join('');
+};
+
+/** `DeepReadonly<T>` |-> `T`, anything else |-> `undefined` */
+const getDeepReadonlyTypeArg = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeNode,
+  deepReadonlyTypeName: string,
+): tsm.TypeNode | undefined => {
+  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+    return undefined;
+  }
+
+  const typeName = node.getTypeName();
+
+  const typeArguments = node.getTypeArguments();
+
+  return typeName.isKind(tsm.SyntaxKind.Identifier) &&
+    typeName.getText() === deepReadonlyTypeName &&
+    Arr.isFixedLengthArray(1, typeArguments)
+    ? typeArguments[0]
+    : undefined;
+};
+
+const checkIfPropertyNameShouldBeIgnored = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  nameNode: tsm.PropertyName,
+  options: ReadonlyTransformerOptionsInternal,
+): boolean => {
+  expectType<typeof nameNode, tsm.PropertyName>('=');
+
+  expectType<
+    tsm.PropertyName,
+    | tsm.NumericLiteral
+    | tsm.BigIntLiteral
+    | tsm.NoSubstitutionTemplateLiteral
+    | tsm.Identifier
+    | tsm.StringLiteral
+    | tsm.PrivateIdentifier
+    | tsm.ComputedPropertyName // [`mut_x`]: number[]
+  >('=');
+
+  return (
+    // mut_x: number[]
+    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
+      pipe(nameNode.getText()).map((nm) =>
+        options.mutablePropertyPrefixes.some((p) => nm.startsWith(p)),
+      ).value) ||
+    // "mut_x": number[]
+    (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
+      pipe(nameNode.getLiteralValue()).map((nm) =>
+        options.mutablePropertyPrefixes.some((p) => nm.startsWith(p)),
+      ).value) ||
+    //  #memberName: number[] (class only), matched with or after its `#`
+    (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
+      pipe(nameNode.getText()).map((nm) =>
+        options.mutablePropertyPrefixes.some(
+          (p) => nm.startsWith(p) || nm.startsWith(`#${p}`),
+        ),
+      ).value) ||
+    // ['mut_x']: number[], [`mut_x`]: number[]
+    (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
+      pipe(nameNode.getExpression()).map((exp) => {
+        if (
+          exp.isKind(tsm.SyntaxKind.StringLiteral) ||
+          exp.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral)
+        ) {
+          const nm = exp.getLiteralValue();
+
+          return options.mutablePropertyPrefixes.some((p) => nm.startsWith(p));
+        }
+
+        return false;
+      }).value)
+  );
+};
+
+/**
+ * Whether a type literal is left without `Readonly<...>` and marked readonly
+ * member by member, because it has a property, a method or an accessor of an
+ * ignored prefix (`{ mut_x: X[] }`), which `transformMembers` leaves mutable
+ * and `Readonly<T>` would not.
+ *
+ * It keeps its `Readonly<...>` when that would leave another member mutable,
+ * since only a property or index signature can be marked `readonly` itself:
+ *
+ * - a method signature or an accessor, which `Readonly<T>` makes readonly too,
+ *   unless its name has an ignored prefix as well;
+ * - a property or index signature the ignore comment skips (as
+ *   `transformMembers` does), which gets no `readonly` of its own, unless it
+ *   is `readonly` already.
+ */
+const isLeftUnwrapped = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeLiteralNode,
+  options: ReadonlyTransformerOptionsInternal,
+): boolean => {
+  const members = node.getMembers();
+
+  const isMethodOrAccessor = (
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    mb: tsm.TypeElementTypes,
+  ): mb is
+    | tsm.MethodSignature
+    | tsm.GetAccessorDeclaration
+    | tsm.SetAccessorDeclaration =>
+    mb.isKind(tsm.SyntaxKind.MethodSignature) ||
+    mb.isKind(tsm.SyntaxKind.GetAccessor) ||
+    mb.isKind(tsm.SyntaxKind.SetAccessor);
+
+  const isIgnoredMember = (
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    mb: tsm.TypeElementTypes,
+  ): boolean =>
+    (mb.isKind(tsm.SyntaxKind.PropertySignature) || isMethodOrAccessor(mb)) &&
+    checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options);
+
+  const needsReadonlyWrapper = (
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    mb: tsm.TypeElementTypes,
+  ): boolean =>
+    !isIgnoredMember(mb) &&
+    (isMethodOrAccessor(mb) ||
+      ((mb.isKind(tsm.SyntaxKind.PropertySignature) ||
+        mb.isKind(tsm.SyntaxKind.IndexSignature)) &&
+        !mb.hasModifier(tsm.SyntaxKind.ReadonlyKeyword) &&
+        hasDisableNextLineComment(mb)));
+
+  return members.some(isIgnoredMember) && !members.some(needsReadonlyWrapper);
+};
+
+/** Whether `node`, or a parenthesized type around it, carries the ignore comment. */
+const hasDisableNextLineCommentAround = (node: tsm.Node): boolean => {
+  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+    return true;
+  }
+
+  const parent = node.getParent();
+
+  return (
+    parent?.isKind(tsm.SyntaxKind.ParenthesizedType) === true &&
+    hasDisableNextLineCommentAround(parent)
+  );
+};
+
+/**
+ * Whether a type literal that is already wrapped, or would be merged into the
+ * `Readonly<...>` of a union or intersection, is taken out of it. See
+ * `isLeftUnwrapped`; in addition, the ignore comment leaves the literal where
+ * it is, and taking `Readonly` off one with a call or construct signature would
+ * bring back the signature it dropped.
+ */
+const takesOffReadonly = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeLiteralNode,
+  options: ReadonlyTransformerOptionsInternal,
+): boolean =>
+  isLeftUnwrapped(node, options) &&
+  !hasCallOrConstructSignature(node) &&
+  !hasDisableNextLineCommentAround(node);
+
+/**
+ * - `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<{ mut_x: X; y: Y }>) |-> { mut_x: X; readonly y: tr(Y) }` (see
+ *   `isLeftUnwrapped`)
+ * - `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)[]>`
+ * - `tr(Record<K, V>) |-> Readonly<Record<tr(K), tr(V)>>` (or
+ *   `ReadonlyRecord<tr(K), tr(V)>`, depending on the `recordStyle` option;
+ *   `Readonly<Record<K, V>>`, `ReadonlyRecord<K, V>` and
+ *   `Readonly<ReadonlyRecord<K, V>>` are unified to the same style)
+ */
+const transformTypeReferenceNode = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeReferenceNode,
+  readonlyContext: StrictExclude<
+    ReadonlyContext,
+    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
+  >,
+  options: ReadonlyTransformerOptionsInternal,
+): void => {
+  const typeNameStr = node.getTypeName().getText();
+
+  const typeArguments = node.getTypeArguments();
+
+  // Array<T> / ReadonlyArray<T> to readonly T[]
+  if (typeNameStr === 'Array' || typeNameStr === 'ReadonlyArray') {
+    if (!Arr.isFixedLengthArray(1, typeArguments)) {
+      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.isFixedLengthArray(1, typeArguments)) {
+      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.isFixedLengthArray(2, typeArguments)) {
+      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;
+  }
+
+  // Record<K, V> to ReadonlyRecord<K, V> / Readonly<Record<K, V>>
+  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',
+    });
+
+    // Recursive processing
+    for (const t of typeArguments) {
+      transformNode(t, nextReadonlyContextValue, options);
+    }
+
+    // The bare Record is kept as is in the following cases:
+    // - DeepReadonly<Record<K, V>> already applies readonly recursively.
+    // - Readonly<Record<K, V>> is unified to the configured record style by
+    //   the surrounding `Readonly` handler.
+    // - Record<K, V>[I] does not need readonly, just like
+    //   `Readonly<{ ... }>[I] -> { ... }[I]`.
+    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;
+  }
+
+  // Unify ReadonlyRecord<K, V> to the configured record style
+  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',
+    });
+
+    // Recursive processing
+    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()}>` as const;
+
+    // Readonly<ReadonlyRecord<K, V>> -> Readonly<Record<K, V>>
+    //   (the surrounding `Readonly` handler then unifies it to the configured
+    //   record style, so the bare Record never survives into the output)
+    if (
+      readonlyContext.type === 'Readonly' &&
+      readonlyContext.indexedAccessDepth === 0
+    ) {
+      options.replaceNode(node, bareRecordText);
+
+      return;
+    }
+
+    if (options.recordStyle === 'Readonly<Record>') {
+      // The ReadonlyRecord name is eliminated everywhere:
+      // - DeepReadonly<ReadonlyRecord<K, V>> -> DeepReadonly<Record<K, V>>
+      // - ReadonlyRecord<K, V>[I] -> Record<K, V>[I]
+      //   (readonly is unnecessary under indexed access, as with
+      //   Readonly<{ ... }>[I] -> { ... }[I])
+      if (
+        readonlyContext.type !== 'none' ||
+        readonlyContext.indexedAccessDepth > 0
+      ) {
+        options.replaceNode(node, bareRecordText);
+
+        return;
+      }
+
+      options.replaceNode(node, `Readonly<${bareRecordText}>`);
+
+      return;
+    }
+
+    // With `recordStyle: "ReadonlyRecord"`, ReadonlyRecord is already the
+    // configured style. It is deliberately kept even under DeepReadonly or an
     // indexed access — stripping it to the bare built-in `Record` there would
     // conflict with the `ts-type-forge/prefer-readonly-or-mutable-record`
     // ESLint rule.
@@ -786,9 +1334,9 @@ const transformTypeReferenceNode = (
       takesOffWrapper ||
       (T.isKind(tsm.SyntaxKind.TypeLiteral) && takesOffReadonly(T, options))
     ) {
-      // The comments after the literal, which nothing else carries over, go
-      // in front of it: a line comment after it would end the type with a
-      // line break, which a following `[]` cannot be parsed across.
+      // The comments after the literal, which nothing else carries over, go in
+      // front of it: a line comment after it would end the type with a line
+      // break, which a following `[]` cannot be parsed across.
       const commentsAfterT = commentsBetween(
         node.getSourceFile(),
         T.getEnd(),
@@ -985,16 +1533,6 @@ const transformTypeReferenceNode = (
   }
 };
 
-/** Renders a readonly `Record<K, V>` in the configured record style. */
-const readonlyRecordText = (
-  keyText: string,
-  valueText: string,
-  options: ReadonlyTransformerOptionsInternal,
-): string =>
-  options.recordStyle === 'ReadonlyRecord'
-    ? (`ReadonlyRecord<${keyText}, ${valueText}>` as const)
-    : (`Readonly<Record<${keyText}, ${valueText}>>` as const);
-
 /** `tr(E[]) |-> tr(E)[]` */
 const transformArrayTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -1445,221 +1983,94 @@ const transformConstructorParameter = (
   if (type !== undefined) {
     transformNode(type, initialReadonlyContext, options);
   }
-};
-
-/**
- * - `tr(A & B) -> tr(A) & tr(B)`
- * - `tr(Readonly<A> & Readonly<B>) -> Readonly<tr(A) & tr(B)>`, when `A` and `B`
- *   are type literals (see `isMergeableReadonlyTypeReferenceNode`)
- */
-const transformIntersectionTypeNode = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.IntersectionTypeNode,
-  readonlyContext: StrictExclude<
-    ReadonlyContext,
-    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
-  >,
-  options: ReadonlyTransformerOptionsInternal,
-): void => {
-  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '&');
-};
-
-/**
- * - `tr(A | B) |-> tr(A) | tr(B)`
- * - `tr(Readonly<A> | Readonly<B>) |-> Readonly<tr(A) | tr(B)>`
- * - `tr(DeepReadonly<A> | DeepReadonly<B>) |-> DeepReadonly<tr(A) | tr(B)>`
- */
-const transformUnionTypeNode = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.UnionTypeNode,
-  readonlyContext: StrictExclude<
-    ReadonlyContext,
-    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
-  >,
-  options: ReadonlyTransformerOptionsInternal,
-): void => {
-  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '|');
-};
-
-const transformUnionOrIntersectionTypeNodeImpl = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.IntersectionTypeNode | tsm.UnionTypeNode,
-  readonlyContext: StrictExclude<
-    ReadonlyContext,
-    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
-  >,
-  options: ReadonlyTransformerOptionsInternal,
-  operator: '&' | '|',
-): void => {
-  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 withLeadingComments = (
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    member: tsm.TypeNode,
-    memberText: string,
-  ): string => `${leadingCommentsOfMember(node, member)}${memberText}` as const;
-
-  // Whether a type literal member is wrapped at all; under `DeepReadonly` or an
-  // indexed access none is.
-  const wrapsTypeLiterals =
-    nextReadonlyContextValue.type !== 'DeepReadonly' &&
-    nextReadonlyContextValue.indexedAccessDepth === 0;
-
-  // `Readonly<A & { b: B }>`: `A` stays under the `Readonly`, which the
-  // handler of `Readonly` then takes off as redundant.
-  const underReadonly =
-    readonlyContext.type === 'Readonly' &&
-    readonlyContext.indexedAccessDepth === 0 &&
-    isTypeArgumentOfReadonly(node);
-
-  const { primitives, arraysAndTuples, typeLiterals, others } =
-    groupUnionIntersectionTypes(newTypes, {
-      operator,
-      underReadonly,
-      deepReadonlyTypeName: options.DeepReadonly.typeName,
-      keptUnwrapped: (t) => wrapsTypeLiterals && takesOffReadonly(t, options),
-    });
-
-  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: tsm.TypeNode,
-  ): boolean =>
-    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: readonly [] | readonly [string] =
-    nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
-      ? ([] as const)
-      : ([
-          unionToString({
-            types: nonEmptyTypeLiterals.map((n) =>
-              withLeadingComments(
-                n,
-                isMergeableReadonlyTypeReferenceNode(n, operator)
-                  ? // NOTE: Readonly<A & B> -> (A & B) (spliced into `|`)
-                    // NOTE: Readonly<A | B> -> A | B (spliced into `|`)
-                    readonlyTypeArgTextSplicedInto(n, operator)
-                  : n.isKind(tsm.SyntaxKind.TypeLiteral)
-                    ? n.getText()
-                    : // A member kept under `Readonly`; see `underReadonly`
-                      wrapWithParentheses(n.getText()),
-              ),
-            ),
-            op: operator,
-            wrapWithReadonly: wrapsTypeLiterals,
-          }),
-        ] as const);
-
-  // Sort by first occurrence (preserving the original union order as much as possible)
-  const sorted: readonly string[] = [
-    mapNullable(
-      primitives,
-      (a) =>
-        [
-          a.nodes.map((n) => withLeadingComments(n, n.getText())),
-          a.firstPosition,
-        ] as const,
-    ),
-    mapNullable(
-      arraysAndTuples,
-      (a) =>
-        [
-          a.nodes.map((n) => withLeadingComments(n, n.getText())),
-          a.firstPosition,
-        ] as const,
-    ),
-    nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
-      ? mapNullable(
-          typeLiterals,
-          (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition] as const,
-        )
-      : undefined,
-    emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
-      ? mapNullable(
-          typeLiterals,
-          (a) =>
-            [
-              emptyTypeLiterals.map((n) => withLeadingComments(n, n.getText())),
-              // Use a position after non-empty type literals if they exist
-              a.firstPosition +
-                (nonEmptyTypeLiterals !== undefined &&
-                Arr.isNonEmpty(nonEmptyTypeLiterals)
-                  ? 0.5
-                  : 0),
-            ] as const,
-        )
-      : undefined,
-    mapNullable(
-      others,
-      (a) =>
-        [
-          // `&` is deliberately not merged, unlike `Readonly<A> & Readonly<B>`
-          // above. See `mergeDeepReadonlyUnionMembers` for why.
-          operator === '|'
-            ? mergeDeepReadonlyUnionMembers(
-                a.nodes,
-                options.DeepReadonly.typeName,
-                withLeadingComments,
-              )
-            : a.nodes.map((n) =>
-                withLeadingComments(n, wrapWithParentheses(n.getText())),
-              ),
-          a.firstPosition,
-        ] as const,
-    ),
-  ]
-    .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 }>
+/**
+ * - `tr(A & B) -> tr(A) & tr(B)`
+ * - `tr(Readonly<A> & Readonly<B>) -> Readonly<tr(A) & tr(B)>`, when `A` and `B`
+ *   are type literals (see `isMergeableReadonlyTypeReferenceNode`)
+ */
+const transformIntersectionTypeNode = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.IntersectionTypeNode,
+  readonlyContext: StrictExclude<
+    ReadonlyContext,
+    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
+  >,
+  options: ReadonlyTransformerOptionsInternal,
+): void => {
+  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '&');
+};
 
-  // 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 }>
+/**
+ * - `tr(A | B) |-> tr(A) | tr(B)`
+ * - `tr(Readonly<A> | Readonly<B>) |-> Readonly<tr(A) | tr(B)>`
+ * - `tr(DeepReadonly<A> | DeepReadonly<B>) |-> DeepReadonly<tr(A) | tr(B)>`
+ */
+const transformUnionTypeNode = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.UnionTypeNode,
+  readonlyContext: StrictExclude<
+    ReadonlyContext,
+    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
+  >,
+  options: ReadonlyTransformerOptionsInternal,
+): void => {
+  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '|');
+};
 
-  // Readonly<number | { x: X } | { y: Y } | readonly E[]>
-  // -> number | readonly E[] | Readonly<{ x: X } | { y: Y }>
-  //
-  // NOTE: The result is wrapped in parentheses (via `unionToString`). This is
-  // intentional and required for precedence safety: without it, a member such
-  // as a function type (`() => T`), or a mix of `&` and `|`, or a `readonly`
-  // operator would produce invalid syntax when this node is spliced back in.
-  // Idempotency is guaranteed by `transformParenthesizedTypeNode`, which
-  // collapses the redundant nesting (`((X))` -> `(X)`) this wrapping can create
-  // — see the note there. That prevents the parentheses from growing without
-  // bound when a union/intersection sits inside a `ParenthesizedType`.
-  options.replaceNode(
-    node,
-    unionToString({ types: sorted, op: operator, wrapWithReadonly: false }),
-  );
+/**
+ * The text of `inner`, a type `removeParentheses` took out of `outer`, with the
+ * comments in `outer`'s full text in front of it — before the parentheses and
+ * inside them — and without the parentheses.
+ *
+ * `inner.getFullText()` would drop those before the parentheses, which are as
+ * much a part of `outer` as the rest of it.
+ */
+const textWithoutParentheses = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  outer: tsm.TypeNode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  inner: tsm.TypeNode,
+): string =>
+  `${commentsBetween(outer.getSourceFile(), outer.getPos(), inner.getStart())}${inner.getText()}` as const;
+
+const unionToStringImpl = ({
+  types,
+  op,
+  wrapWithReadonly,
+}: Readonly<{
+  types: readonly string[];
+  op: '&' | '|';
+  wrapWithReadonly: boolean | string;
+}>): string =>
+  Arr.isEmpty(types)
+    ? 'never'
+    : Arr.isFixedLengthArray(1, types)
+      ? wrapWithReadonly === false
+        ? wrapWithParentheses(types[0])
+        : (`${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>` as const)
+      : wrapWithReadonly === false
+        ? wrapWithParentheses(types.join(` ${op} `))
+        : (`${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types.join(` ${op} `)}>` as const);
+
+const unionToString = ({
+  types: typesRaw,
+  op,
+  wrapWithReadonly,
+}: Readonly<{
+  types: readonly string[];
+  op: '&' | '|';
+  wrapWithReadonly: boolean | string;
+}>): string => {
+  // The members are joined with a separator that supplies its own space, so
+  // whitespace left at a member's edge would accumulate: every run of the
+  // transformer would add one more space before every member but the first, and
+  // a file would never reach a fixed point. Trimming keeps the comments in
+  // front of a member, which are not whitespace.
+  const types = typesRaw.map((s) => s.trim());
+
+  return unionToStringImpl({ types, op, wrapWithReadonly });
 };
 
 /**
@@ -1775,10 +2186,10 @@ const isTypeArgumentOfReadonly = (
  * `replaceWithText` overwrites a node from its `getStart()`, so whatever lies
  * in front of that stays in the file by itself. With no leading `|` / `&`, the
  * first member starts there too, and its comments are the type's: repeating
- * them in the replacement would copy them once per run. Every other member
- * has a separator in front of it, and a comment before the separator belongs
- * to no member's full text, so it is gone once the separator is rewritten. It
- * goes with the member after it, like the comments after the separator.
+ * them in the replacement would copy them once per run. Every other member has
+ * a separator in front of it, and a comment before the separator belongs to no
+ * member's full text, so it is gone once the separator is rewritten. It goes
+ * with the member after it, like the comments after the separator.
  *
  * `member` may be the type inside a member's parentheses; the comments inside
  * them are collected too, and the parentheses are not.
@@ -1802,9 +2213,9 @@ const leadingCommentsOfMember = (
  * `Readonly<T>` |-> the text of `T`, to be spliced into a union (`|`) or an
  * intersection (`&`) of the members it is merged with.
  *
- * `T` is wrapped in parentheses for precedence safety (a function type
- * argument needs them), unless it is a union spliced into a union or an
- * intersection spliced into an intersection, which needs none.
+ * `T` is wrapped in parentheses for precedence safety (a function type argument
+ * needs them), unless it is a union spliced into a union or an intersection
+ * spliced into an intersection, which needs none.
  */
 const readonlyTypeArgTextSplicedInto = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -1824,127 +2235,187 @@ const readonlyTypeArgTextSplicedInto = (
     : unwrapReadonlyTypeArgText(node);
 };
 
-/**
- * The text of `inner`, a type `removeParentheses` took out of `outer`, with
- * the comments in `outer`'s full text in front of it — before the parentheses
- * and inside them — and without the parentheses.
- *
- * `inner.getFullText()` would drop those before the parentheses, which are
- * as much a part of `outer` as the rest of it.
- */
-const textWithoutParentheses = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  outer: tsm.TypeNode,
+const transformUnionOrIntersectionTypeNodeImpl = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  inner: tsm.TypeNode,
-): string =>
-  `${commentsBetween(outer.getSourceFile(), outer.getPos(), inner.getStart())}${inner.getText()}` as const;
+  node: tsm.IntersectionTypeNode | tsm.UnionTypeNode,
+  readonlyContext: StrictExclude<
+    ReadonlyContext,
+    Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
+  >,
+  options: ReadonlyTransformerOptionsInternal,
+  operator: '&' | '|',
+): void => {
+  const nextReadonlyContextValue = nextReadonlyContext({
+    currentReadonlyContext: readonlyContext,
+    nextReadonlyContextType: 'none',
+    indexedAccessDepthChange: 'keep',
+  });
 
-/**
- * The comments in `[from, to)` of a source file, each followed by what keeps
- * the next token off it, and nothing else in that range — no whitespace, and
- * no token such as a separator or a parenthesis.
- */
-const commentsBetween = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceFile: tsm.SourceFile,
-  from: number,
-  to: number,
-): string => {
-  if (to <= from) {
-    return '';
+  // Recursive processing
+  for (const n of node.getTypeNodes() /* = [A, B] */) {
+    transformNode(n, nextReadonlyContextValue, options);
   }
 
-  const scanner = tsm.ts.createScanner(
-    tsm.ts.ScriptTarget.Latest,
-    false,
-    tsm.ts.LanguageVariant.Standard,
-    sourceFile.getFullText(),
-    undefined,
-    from,
-    to - from,
-  );
+  const newTypes = node.getTypeNodes();
 
-  const mut_comments: string[] = [];
+  const withLeadingComments = (
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    member: tsm.TypeNode,
+    memberText: string,
+  ): string => `${leadingCommentsOfMember(node, member)}${memberText}` as const;
 
-  while (scanner.scan() !== tsm.ts.SyntaxKind.EndOfFileToken) {
-    const token = scanner.getToken();
+  // Whether a type literal member is wrapped at all; under `DeepReadonly` or an
+  // indexed access none is.
+  const wrapsTypeLiterals =
+    nextReadonlyContextValue.type !== 'DeepReadonly' &&
+    nextReadonlyContextValue.indexedAccessDepth === 0;
 
-    // A line comment runs to the end of the line, so it takes one along.
-    const separator =
-      token === tsm.ts.SyntaxKind.SingleLineCommentTrivia
-        ? '\n'
-        : token === tsm.ts.SyntaxKind.MultiLineCommentTrivia
-          ? ' '
-          : undefined;
+  // `Readonly<A & { b: B }>`: `A` stays under the `Readonly`, which the handler
+  // of `Readonly` then takes off as redundant.
+  const underReadonly =
+    readonlyContext.type === 'Readonly' &&
+    readonlyContext.indexedAccessDepth === 0 &&
+    isTypeArgumentOfReadonly(node);
 
-    if (separator !== undefined) {
-      mut_comments.push(`${scanner.getTokenText()}${separator}`);
-    }
-  }
+  const { primitives, arraysAndTuples, typeLiterals, others } =
+    groupUnionIntersectionTypes(newTypes, {
+      operator,
+      underReadonly,
+      deepReadonlyTypeName: options.DeepReadonly.typeName,
+      keptUnwrapped: (t) => wrapsTypeLiterals && takesOffReadonly(t, options),
+    });
 
-  return mut_comments.join('');
-};
+  options.debugPrint({ primitives, arraysAndTuples, typeLiterals, others });
 
-/** `DeepReadonly<T>` |-> `T`, anything else |-> `undefined` */
-const getDeepReadonlyTypeArg = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.TypeNode,
-  deepReadonlyTypeName: string,
-): tsm.TypeNode | undefined => {
-  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
-    return undefined;
-  }
+  // 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: tsm.TypeNode,
+  ): boolean =>
+    n.isKind(tsm.SyntaxKind.TypeLiteral) && Arr.isEmpty(n.getMembers());
 
-  const typeName = node.getTypeName();
+  const nonEmptyTypeLiterals =
+    typeLiterals === undefined
+      ? undefined
+      : options.ignoreEmptyObjectTypes
+        ? typeLiterals.nodes.filter((n) => !isEmptyTypeLiteral(n))
+        : typeLiterals.nodes;
 
-  const typeArguments = node.getTypeArguments();
+  const emptyTypeLiterals =
+    typeLiterals === undefined || !options.ignoreEmptyObjectTypes
+      ? undefined
+      : typeLiterals.nodes.filter(isEmptyTypeLiteral);
+
+  const typeLiteralsWrappedWithReadonly: readonly [] | readonly [string] =
+    nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
+      ? ([] as const)
+      : ([
+          unionToString({
+            types: nonEmptyTypeLiterals.map((n) =>
+              withLeadingComments(
+                n,
+                isMergeableReadonlyTypeReferenceNode(n, operator)
+                  ? // NOTE: Readonly<A & B> -> (A & B) (spliced into `|`)
+                    // NOTE: Readonly<A | B> -> A | B (spliced into `|`)
+                    readonlyTypeArgTextSplicedInto(n, operator)
+                  : n.isKind(tsm.SyntaxKind.TypeLiteral)
+                    ? n.getText()
+                    : // A member kept under `Readonly`; see `underReadonly`
+                      wrapWithParentheses(n.getText()),
+              ),
+            ),
+            op: operator,
+            wrapWithReadonly: wrapsTypeLiterals,
+          }),
+        ] as const);
+
+  // Sort by first occurrence (preserving the original union order as much as possible)
+  const sorted: readonly string[] = [
+    mapNullable(
+      primitives,
+      (a) =>
+        [
+          a.nodes.map((n) => withLeadingComments(n, n.getText())),
+          a.firstPosition,
+        ] as const,
+    ),
+    mapNullable(
+      arraysAndTuples,
+      (a) =>
+        [
+          a.nodes.map((n) => withLeadingComments(n, n.getText())),
+          a.firstPosition,
+        ] as const,
+    ),
+    nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
+      ? mapNullable(
+          typeLiterals,
+          (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition] as const,
+        )
+      : undefined,
+    emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
+      ? mapNullable(
+          typeLiterals,
+          (a) =>
+            [
+              emptyTypeLiterals.map((n) => withLeadingComments(n, n.getText())),
+              // Use a position after non-empty type literals if they exist
+              a.firstPosition +
+                (nonEmptyTypeLiterals !== undefined &&
+                Arr.isNonEmpty(nonEmptyTypeLiterals)
+                  ? 0.5
+                  : 0),
+            ] as const,
+        )
+      : undefined,
+    mapNullable(
+      others,
+      (a) =>
+        [
+          // `&` is deliberately not merged, unlike `Readonly<A> & Readonly<B>`
+          // above. See `mergeDeepReadonlyUnionMembers` for why.
+          operator === '|'
+            ? mergeDeepReadonlyUnionMembers(
+                a.nodes,
+                options.DeepReadonly.typeName,
+                withLeadingComments,
+              )
+            : a.nodes.map((n) =>
+                withLeadingComments(n, wrapWithParentheses(n.getText())),
+              ),
+          a.firstPosition,
+        ] as const,
+    ),
+  ]
+    .filter((x) => x !== undefined)
+    .toSorted((a, b) => a[1] - b[1])
+    .flatMap((a) => a[0]);
 
-  return typeName.isKind(tsm.SyntaxKind.Identifier) &&
-    typeName.getText() === deepReadonlyTypeName &&
-    Arr.isFixedLengthArray(1, typeArguments)
-    ? typeArguments[0]
-    : undefined;
-};
+  // Readonly<number & { x: X } & { y: Y } & readonly E[]>
+  // -> number & readonly E[] & Readonly<{ x: X } & { y: Y }>
 
-const unionToString = ({
-  types: typesRaw,
-  op,
-  wrapWithReadonly,
-}: Readonly<{
-  types: readonly string[];
-  op: '&' | '|';
-  wrapWithReadonly: boolean | string;
-}>): string => {
-  // The members are joined with a separator that supplies its own space, so
-  // whitespace left at a member's edge would accumulate: every run of the
-  // transformer would add one more space before every member but the first,
-  // and a file would never reach a fixed point. Trimming keeps the comments in
-  // front of a member, which are not whitespace.
-  const types = typesRaw.map((s) => s.trim());
+  // 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 }>
 
-  return unionToStringImpl({ types, op, wrapWithReadonly });
+  // Readonly<number | { x: X } | { y: Y } | readonly E[]>
+  // -> number | readonly E[] | Readonly<{ x: X } | { y: Y }>
+  //
+  // NOTE: The result is wrapped in parentheses (via `unionToString`). This is
+  // intentional and required for precedence safety: without it, a member such
+  // as a function type (`() => T`), or a mix of `&` and `|`, or a `readonly`
+  // operator would produce invalid syntax when this node is spliced back in.
+  // Idempotency is guaranteed by `transformParenthesizedTypeNode`, which
+  // collapses the redundant nesting (`((X))` -> `(X)`) this wrapping can create
+  // — see the note there. That prevents the parentheses from growing without
+  // bound when a union/intersection sits inside a `ParenthesizedType`.
+  options.replaceNode(
+    node,
+    unionToString({ types: sorted, op: operator, wrapWithReadonly: false }),
+  );
 };
 
-const unionToStringImpl = ({
-  types,
-  op,
-  wrapWithReadonly,
-}: Readonly<{
-  types: readonly string[];
-  op: '&' | '|';
-  wrapWithReadonly: boolean | string;
-}>): string =>
-  Arr.isEmpty(types)
-    ? 'never'
-    : Arr.isFixedLengthArray(1, types)
-      ? wrapWithReadonly === false
-        ? wrapWithParentheses(types[0])
-        : (`${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>` as const)
-      : wrapWithReadonly === false
-        ? wrapWithParentheses(types.join(` ${op} `))
-        : (`${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types.join(` ${op} `)}>` as const);
-
 /** Convert ((T)) -> (T) recursively */
 const transformParenthesizedTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -1964,20 +2435,16 @@ const transformParenthesizedTypeNode = (
   const T = node.getTypeNode();
 
   if (
-    // remove () if T is TypeReferenceNode
-    // e.g. `(Readonly<A>) |-> Readonly<A>`
+    // 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[]`
+    // remove () if T is ArrayTypeNode e.g. `(A[]) |-> A[]`
     T.isKind(tsm.SyntaxKind.ArrayType) ||
-    // remove () if T is TupleTypeNode
-    // e.g. `([A]) |-> [A]`
+    // remove () if T is TupleTypeNode e.g. `([A]) |-> [A]`
     T.isKind(tsm.SyntaxKind.TupleType) ||
-    // remove () if T is PrimitiveTypeNode
-    // e.g. `(number) |-> number`
+    // remove () if T is PrimitiveTypeNode e.g. `(number) |-> number`
     isAtomicTypeNode(T) ||
-    // remove () if T is TypeLiteralNode
-    // e.g. `({ member: V }) |-> { member: V }`
+    // 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)`
@@ -2134,161 +2601,3 @@ const transformIndexSignatureDeclaration = (
     }
   }
 };
-
-const checkIfPropertyNameShouldBeIgnored = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  nameNode: tsm.PropertyName,
-  options: ReadonlyTransformerOptionsInternal,
-): boolean => {
-  expectType<typeof nameNode, tsm.PropertyName>('=');
-
-  expectType<
-    tsm.PropertyName,
-    | tsm.NumericLiteral
-    | tsm.BigIntLiteral
-    | tsm.NoSubstitutionTemplateLiteral
-    | tsm.Identifier
-    | tsm.StringLiteral
-    | tsm.PrivateIdentifier
-    | tsm.ComputedPropertyName // [`mut_x`]: number[]
-  >('=');
-
-  return (
-    // mut_x: number[]
-    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
-      pipe(nameNode.getText()).map((nm) =>
-        options.mutablePropertyPrefixes.some((p) => nm.startsWith(p)),
-      ).value) ||
-    // "mut_x": number[]
-    (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
-      pipe(nameNode.getLiteralValue()).map((nm) =>
-        options.mutablePropertyPrefixes.some((p) => nm.startsWith(p)),
-      ).value) ||
-    //  #memberName: number[] (class only), matched with or after its `#`
-    (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
-      pipe(nameNode.getText()).map((nm) =>
-        options.mutablePropertyPrefixes.some(
-          (p) => nm.startsWith(p) || nm.startsWith(`#${p}`),
-        ),
-      ).value) ||
-    // ['mut_x']: number[], [`mut_x`]: number[]
-    (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
-      pipe(nameNode.getExpression()).map((exp) => {
-        if (
-          exp.isKind(tsm.SyntaxKind.StringLiteral) ||
-          exp.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral)
-        ) {
-          const nm = exp.getLiteralValue();
-
-          return options.mutablePropertyPrefixes.some((p) => nm.startsWith(p));
-        }
-
-        return false;
-      }).value)
-  );
-};
-
-/**
- * Whether a type literal is left without `Readonly<...>` and marked readonly
- * member by member, because it has a property, a method or an accessor of an
- * ignored prefix (`{ mut_x: X[] }`), which `transformMembers` leaves mutable
- * and `Readonly<T>` would not.
- *
- * It keeps its `Readonly<...>` when that would leave another member mutable,
- * since only a property or index signature can be marked `readonly` itself:
- *
- * - a method signature or an accessor, which `Readonly<T>` makes readonly too,
- *   unless its name has an ignored prefix as well;
- * - a property or index signature the ignore comment skips (as
- *   `transformMembers` does), which gets no `readonly` of its own, unless it
- *   is `readonly` already.
- */
-const isLeftUnwrapped = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.TypeLiteralNode,
-  options: ReadonlyTransformerOptionsInternal,
-): boolean => {
-  const members = node.getMembers();
-
-  const isMethodOrAccessor = (
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    mb: tsm.TypeElementTypes,
-  ): mb is
-    | tsm.MethodSignature
-    | tsm.GetAccessorDeclaration
-    | tsm.SetAccessorDeclaration =>
-    mb.isKind(tsm.SyntaxKind.MethodSignature) ||
-    mb.isKind(tsm.SyntaxKind.GetAccessor) ||
-    mb.isKind(tsm.SyntaxKind.SetAccessor);
-
-  const isIgnoredMember = (
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    mb: tsm.TypeElementTypes,
-  ): boolean =>
-    (mb.isKind(tsm.SyntaxKind.PropertySignature) || isMethodOrAccessor(mb)) &&
-    checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options);
-
-  const needsReadonlyWrapper = (
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    mb: tsm.TypeElementTypes,
-  ): boolean =>
-    !isIgnoredMember(mb) &&
-    (isMethodOrAccessor(mb) ||
-      ((mb.isKind(tsm.SyntaxKind.PropertySignature) ||
-        mb.isKind(tsm.SyntaxKind.IndexSignature)) &&
-        !mb.hasModifier(tsm.SyntaxKind.ReadonlyKeyword) &&
-        hasDisableNextLineComment(mb)));
-
-  return members.some(isIgnoredMember) && !members.some(needsReadonlyWrapper);
-};
-
-/** Whether `node`, or a parenthesized type around it, carries the ignore comment. */
-const hasDisableNextLineCommentAround = (node: tsm.Node): boolean => {
-  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-    return true;
-  }
-
-  const parent = node.getParent();
-
-  return (
-    parent?.isKind(tsm.SyntaxKind.ParenthesizedType) === true &&
-    hasDisableNextLineCommentAround(parent)
-  );
-};
-
-/**
- * Whether a type literal that is already wrapped, or would be merged into the
- * `Readonly<...>` of a union or intersection, is taken out of it. See
- * `isLeftUnwrapped`; in addition, the ignore comment leaves the literal where
- * it is, and taking `Readonly` off one with a call or construct signature
- * would bring back the signature it dropped.
- */
-const takesOffReadonly = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: tsm.TypeLiteralNode,
-  options: ReadonlyTransformerOptionsInternal,
-): boolean =>
-  isLeftUnwrapped(node, options) &&
-  !hasCallOrConstructSignature(node) &&
-  !hasDisableNextLineCommentAround(node);
-
-/** Whether a type alias, interface or class name starts with a `mutableTypePrefixes` entry. */
-const hasMutableTypeName = (
-  name: string | undefined,
-  options: ReadonlyTransformerOptionsInternal,
-): boolean =>
-  name !== undefined &&
-  options.mutableTypePrefixes.some((p) => name.startsWith(p));
-
-/**
- * A parameter property is a property of the class, as a `PropertyDeclaration`
- * is; any other parameter is a variable.
- */
-const mutablePrefixesOfParameter = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  param: tsm.ParameterDeclaration,
-  options: ReadonlyTransformerOptionsInternal,
-): ISet<string> =>
-  param.isParameterProperty()
-    ? options.mutablePropertyPrefixes
-    : options.mutableVariablePrefixes;