ts-codemod-lib 3.3.0 → 3.3.2

package/dist/functions/functions/is-atomic-type-node.mjs

@@ -2,31 +2,251 @@ import { ISet } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 
 const atomicTypeKeywordKinds = ISet.create([
-  tsm.SyntaxKind.StringKeyword,
-  tsm.SyntaxKind.BooleanKeyword,
-  tsm.SyntaxKind.NumberKeyword,
-  tsm.SyntaxKind.BigIntKeyword,
-  tsm.SyntaxKind.SymbolKeyword,
-  tsm.SyntaxKind.UndefinedKeyword,
-  tsm.SyntaxKind.VoidKeyword,
-  tsm.SyntaxKind.AnyKeyword,
-  tsm.SyntaxKind.UnknownKeyword,
-  tsm.SyntaxKind.ObjectKeyword,
-  // Note: 'object' is sometimes considered primitive in TS type system context
-  tsm.SyntaxKind.NeverKeyword
+    tsm.SyntaxKind.StringKeyword,
+    tsm.SyntaxKind.BooleanKeyword,
+    tsm.SyntaxKind.NumberKeyword,
+    tsm.SyntaxKind.BigIntKeyword,
+    tsm.SyntaxKind.SymbolKeyword,
+    tsm.SyntaxKind.UndefinedKeyword,
+    tsm.SyntaxKind.VoidKeyword,
+    tsm.SyntaxKind.AnyKeyword,
+    tsm.SyntaxKind.UnknownKeyword,
+    tsm.SyntaxKind.ObjectKeyword,
+    tsm.SyntaxKind.NeverKeyword,
 ]);
-const isAtomicTypeNode = (node) => {
-  if (node.isKind(tsm.SyntaxKind.LiteralType)) {
-    return true;
-  }
-  if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {
-    return true;
-  }
-  if (atomicTypeKeywordKinds.has(node.getKind())) {
-    return true;
-  }
-  return false;
+
+
+
+
+
+
+
+
+
+export const isAtomicTypeNode = (node) => {
+
+    if (node.isKind(tsm.SyntaxKind.LiteralType)) {
+        return true;
+    }
+
+    if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {
+        return true;
+    }
+
+
+
+    if (atomicTypeKeywordKinds.has(node.getKind())) {
+        return true;
+    }
+    return false;
 };
 
-export { isAtomicTypeNode };
-//# sourceMappingURL=is-atomic-type-node.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=is-atomic-type-node.mjs.map

package/dist/functions/functions/is-atomic-type-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-atomic-type-node.mjs","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"sourcesContent":["import { ISet } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly } from 'ts-type-forge';\n\n// Define the set of SyntaxKinds that represent primitive type keywords\nconst atomicTypeKeywordKinds = ISet.create<tsm.SyntaxKind>([\n  tsm.SyntaxKind.StringKeyword,\n  tsm.SyntaxKind.BooleanKeyword,\n  tsm.SyntaxKind.NumberKeyword,\n  tsm.SyntaxKind.BigIntKeyword,\n  tsm.SyntaxKind.SymbolKeyword,\n  tsm.SyntaxKind.UndefinedKeyword,\n  tsm.SyntaxKind.VoidKeyword,\n  tsm.SyntaxKind.AnyKeyword,\n  tsm.SyntaxKind.UnknownKeyword,\n  tsm.SyntaxKind.ObjectKeyword, // Note: 'object' is sometimes considered primitive in TS type system context\n  tsm.SyntaxKind.NeverKeyword,\n]);\n\n// transformer-ignore-next-line convert-to-readonly\nexport type AtomicTypeNode = tsm.Node &\n  Readonly<\n    | tsm.LiteralTypeNode\n    | tsm.TemplateLiteralTypeNode\n    | (tsm.TypeNode & {\n        kind:\n          | tsm.SyntaxKind.StringKeyword\n          | tsm.SyntaxKind.BooleanKeyword\n          | tsm.SyntaxKind.NumberKeyword\n          | tsm.SyntaxKind.BigIntKeyword\n          | tsm.SyntaxKind.SymbolKeyword\n          | tsm.SyntaxKind.UndefinedKeyword\n          | tsm.SyntaxKind.VoidKeyword\n          | tsm.SyntaxKind.AnyKeyword\n          | tsm.SyntaxKind.UnknownKeyword\n          | tsm.SyntaxKind.ObjectKeyword\n          | tsm.SyntaxKind.NeverKeyword;\n      })\n  >;\n\n/**\n * Checks if a given ts-morph node represents a primitive type node.\n * This includes keyword types (string, number, etc.), literal types (null, \"abc\", 123),\n * and template literal types.\n *\n * @param node - The ts-morph node to check.\n * @returns True if the node represents a primitive type node, false otherwise.\n *          Acts as a type guard.\n */\nexport const isAtomicTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is AtomicTypeNode => {\n  // Check for literal types (null, \"aaa\", 1.23, 456n, true, false)\n  if (node.isKind(tsm.SyntaxKind.LiteralType)) {\n    return true;\n  }\n\n  // Check for template literal types (`abc${expr}def`)\n  if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {\n    return true;\n  }\n\n  // Check if it's a TypeNode and its kind is one of the primitive keywords\n  // Node.isTypeNode(node) ensures we only check nodes that represent types\n  // if (ts.Node.isTypeNode(node) && primitiveKeywordKinds.has(node.getKind())) {\n  if (atomicTypeKeywordKinds.has(node.getKind())) {\n    return true;\n  }\n\n  return false;\n};\n\nif (import.meta.vitest !== undefined) {\n  // Helper to get a specific type node from source code\n  const getTypeNodeFromSource = (\n    sourceCode: string,\n    typeName: string,\n  ): tsm.TypeNode => {\n    const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n    const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n    const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);\n\n    return typeAlias.getTypeNodeOrThrow();\n  };\n\n  // Helper to get the first node of a specific kind from source code\n  const getFirstNodeOfKind = <T extends tsm.Node>(\n    sourceCode: string,\n    kind: tsm.SyntaxKind,\n  ): T | undefined => {\n    const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n    const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return sourceFile.getFirstDescendantByKind(kind) as T | undefined;\n  };\n\n  describe('isAtomicTypeNode', () => {\n    describe('positive cases', () => {\n      test.each([\n        {\n          name: 'string',\n          code: 'type Test = string;',\n          kind: tsm.SyntaxKind.StringKeyword,\n        },\n        {\n          name: 'number',\n          code: 'type Test = number;',\n          kind: tsm.SyntaxKind.NumberKeyword,\n        },\n        {\n          name: 'boolean',\n          code: 'type Test = boolean;',\n          kind: tsm.SyntaxKind.BooleanKeyword,\n        },\n        {\n          name: 'bigint',\n          code: 'type Test = bigint;',\n          kind: tsm.SyntaxKind.BigIntKeyword,\n        },\n        {\n          name: 'symbol',\n          code: 'type Test = symbol;',\n          kind: tsm.SyntaxKind.SymbolKeyword,\n        },\n        {\n          name: 'undefined',\n          code: 'type Test = undefined;',\n          kind: tsm.SyntaxKind.UndefinedKeyword,\n        },\n        {\n          name: 'void',\n          code: 'type Test = void;',\n          kind: tsm.SyntaxKind.VoidKeyword,\n        },\n        {\n          name: 'any',\n          code: 'type Test = any;',\n          kind: tsm.SyntaxKind.AnyKeyword,\n        },\n        {\n          name: 'unknown',\n          code: 'type Test = unknown;',\n          kind: tsm.SyntaxKind.UnknownKeyword,\n        },\n        {\n          name: 'never',\n          code: 'type Test = never;',\n          kind: tsm.SyntaxKind.NeverKeyword,\n        },\n        {\n          name: 'object',\n          code: 'type Test = object;',\n          kind: tsm.SyntaxKind.ObjectKeyword,\n        }, // Included based on original code\n        {\n          name: 'null',\n          code: 'type Test = null;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'string literal (\"hello\")',\n          code: 'type Test = \"hello\";',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'number literal (123)',\n          code: 'type Test = 123;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'bigint literal (123n)',\n          code: 'type Test = 123n;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'boolean literal (true)',\n          code: 'type Test = true;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'boolean literal (false)',\n          code: 'type Test = false;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'TemplateLiteral',\n          // eslint-disable-next-line no-template-curly-in-string\n          code: 'type Test = `a${string}b`;',\n          kind: tsm.SyntaxKind.TemplateLiteralType,\n        },\n      ])('$name', ({ code, kind }) => {\n        const node = getTypeNodeFromSource(code, 'Test');\n\n        expect(node.getKind()).toBe(kind);\n\n        assert.isTrue(isAtomicTypeNode(node));\n      });\n    });\n\n    describe('negative cases', () => {\n      test.each([\n        {\n          name: 'Date TypeReference',\n          code: 'type Test = Date;',\n          kind: tsm.SyntaxKind.TypeReference,\n        },\n        {\n          name: 'Array Type',\n          code: 'type Test = number[];',\n          kind: tsm.SyntaxKind.ArrayType,\n        },\n        {\n          name: 'Tuple Type',\n          code: 'type Test = [string, number];',\n          kind: tsm.SyntaxKind.TupleType,\n        },\n        {\n          name: 'Type Literal',\n          code: 'type Test = { a: number };',\n          kind: tsm.SyntaxKind.TypeLiteral,\n        },\n        {\n          name: 'Readonly Type Operator',\n          code: 'type Test = readonly string[];',\n          kind: tsm.SyntaxKind.TypeOperator,\n        },\n        {\n          name: 'Union Type',\n          code: 'type Test = string | number;',\n          kind: tsm.SyntaxKind.UnionType,\n        },\n        {\n          name: 'Intersection Type',\n          code: 'type Test = A & B;',\n          kind: tsm.SyntaxKind.IntersectionType,\n        },\n        {\n          name: 'Mapped Type',\n          code: 'type Test = { [K in keyof T]: T[K] };',\n          kind: tsm.SyntaxKind.MappedType,\n        }, // Needs T defined\n        {\n          name: 'Parenthesized Type',\n          code: 'type Test = (string);',\n          kind: tsm.SyntaxKind.ParenthesizedType,\n        },\n        {\n          name: 'Conditional Type',\n          code: 'type Test = T extends U ? X : Y;',\n          kind: tsm.SyntaxKind.ConditionalType,\n        }, // Needs T, U, X, Y\n        {\n          name: 'Indexed Access Type',\n          code: 'type Test = T[K];',\n          kind: tsm.SyntaxKind.IndexedAccessType,\n        }, // Needs T, K\n        {\n          name: 'Type Query (typeof)',\n          code: 'type Test = typeof myVar;',\n          kind: tsm.SyntaxKind.TypeQuery,\n        },\n      ])('$name', ({ code, kind }) => {\n        const node = getTypeNodeFromSource(code, 'Test');\n\n        expect(node.getKind()).toBe(kind); // Verify node type\n\n        assert.isFalse(isAtomicTypeNode(node));\n      });\n\n      test.each([\n        {\n          name: 'Type Predicate',\n          code: 'function isString(x: any): x is string { return typeof x === \"string\"; }',\n          kind: tsm.SyntaxKind.TypePredicate,\n        }, // Node is part of function sig\n        {\n          name: 'This Type',\n          code: 'class C { method(): this {} }',\n          kind: tsm.SyntaxKind.ThisType,\n        }, // Node is part of method sig\n        {\n          name: 'Infer Type',\n          code: 'type Test<T> = T extends Promise<infer R> ? R : T;',\n          kind: tsm.SyntaxKind.InferType,\n        }, // Needs context\n      ])('$name (not a type node)', ({ code, kind }) => {\n        const node = getFirstNodeOfKind(code, kind);\n\n        expect(node).toBeDefined();\n\n        if (node === undefined) {\n          throw new Error('Node should be defined');\n        }\n\n        assert.isFalse(isAtomicTypeNode(node));\n      });\n    });\n  });\n}\n"],"names":[],"mappings":";;;AAKA,MAAM,sBAAA,GAAyB,KAAK,MAAA,CAAuB;AAAA,EACzD,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,cAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,gBAAA;AAAA,EACf,IAAI,UAAA,CAAW,WAAA;AAAA,EACf,IAAI,UAAA,CAAW,UAAA;AAAA,EACf,IAAI,UAAA,CAAW,cAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA;AAAA,EACf,IAAI,UAAA,CAAW;AACjB,CAAC,CAAA;AAgCM,MAAM,gBAAA,GAAmB,CAC9B,IAAA,KAC2B;AAE3B,EAAA,IAAI,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC3C,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,IAAI,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,mBAAmB,CAAA,EAAG;AACnD,IAAA,OAAO,IAAA;AAAA,EACT;AAKA,EAAA,IAAI,sBAAA,CAAuB,GAAA,CAAI,IAAA,CAAK,OAAA,EAAS,CAAA,EAAG;AAC9C,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,OAAO,KAAA;AACT;;;;"}
+{"version":3,"file":"is-atomic-type-node.mjs","sourceRoot":"","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"names":[],"mappings":"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"}

package/dist/functions/functions/is-conditional-type-distribution-guard.mjs

@@ -1,16 +1,37 @@
 import * as tsm from 'ts-morph';
 
-const isConditionalTypeDistributionGuard = (node) => {
-  const parent = node.getParent();
-  if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {
-    return false;
-  }
-  const checkType = parent.getCheckType();
-  if (!checkType.isKind(tsm.SyntaxKind.TupleType) && !checkType.isKind(tsm.SyntaxKind.ArrayType)) {
-    return false;
-  }
-  return checkType.compilerNode === node.compilerNode || parent.getExtendsType().compilerNode === node.compilerNode;
-};
 
-export { isConditionalTypeDistributionGuard };
-//# sourceMappingURL=is-conditional-type-distribution-guard.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isConditionalTypeDistributionGuard = (node) => {
+    const parent = node.getParent();
+    if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {
+        return false;
+    }
+    const checkType = parent.getCheckType();
+
+
+    if (!checkType.isKind(tsm.SyntaxKind.TupleType) &&
+        !checkType.isKind(tsm.SyntaxKind.ArrayType)) {
+        return false;
+    }
+    return (checkType.compilerNode === node.compilerNode ||
+        parent.getExtendsType().compilerNode === node.compilerNode);
+};
+//# sourceMappingURL=is-conditional-type-distribution-guard.mjs.map

package/dist/functions/functions/is-conditional-type-distribution-guard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-conditional-type-distribution-guard.mjs","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n/**\n * Determines whether a type node is an operand (check or extends type) of a\n * conditional type whose check type is wrapped to suppress union distribution,\n * i.e. the `X` and `Y` in `X extends Y ? ... : ...` where `X` is itself a tuple\n * or array.\n *\n * Wrapping a naked type parameter so that it is no longer naked is a well-known\n * type-implementation idiom used to suppress union distribution. Both\n * `[A] extends [B] ? ...` (tuple wrapping) and `A[] extends B[] ? ...` (array\n * wrapping) rely on this. Adding a `readonly` modifier to those operands neither\n * makes the type more immutable in any meaningful way nor preserves the idiom's\n * intent, so such operands must be left untouched.\n *\n * A naked check type such as `T extends string[] ? ...` still distributes, so it\n * is not a guard; arrays/tuples in its extends position are converted as usual.\n *\n * @param node - The type node to check\n * @returns true if the node is the check or extends type of a distribution-guarded\n *   conditional type\n */\nexport const isConditionalTypeDistributionGuard = (node: tsm.Node): boolean => {\n  const parent = node.getParent();\n\n  if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {\n    return false;\n  }\n\n  const checkType = parent.getCheckType();\n\n  // The guard is only in effect when the check type itself is wrapped in a tuple\n  // or array; otherwise (e.g. a naked `T`) the conditional still distributes.\n  if (\n    !checkType.isKind(tsm.SyntaxKind.TupleType) &&\n    !checkType.isKind(tsm.SyntaxKind.ArrayType)\n  ) {\n    return false;\n  }\n\n  return (\n    checkType.compilerNode === node.compilerNode ||\n    parent.getExtendsType().compilerNode === node.compilerNode\n  );\n};\n"],"names":[],"mappings":";;AAsBO,MAAM,kCAAA,GAAqC,CAAC,IAAA,KAA4B;AAC7E,EAAA,MAAM,MAAA,GAAS,KAAK,SAAA,EAAU;AAE9B,EAAA,IAAI,QAAQ,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,eAAe,MAAM,IAAA,EAAM;AAC3D,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,SAAA,GAAY,OAAO,YAAA,EAAa;AAItC,EAAA,IACE,CAAC,SAAA,CAAU,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,IAC1C,CAAC,SAAA,CAAU,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,EAC1C;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OACE,SAAA,CAAU,iBAAiB,IAAA,CAAK,YAAA,IAChC,OAAO,cAAA,EAAe,CAAE,iBAAiB,IAAA,CAAK,YAAA;AAElD;;;;"}
+{"version":3,"file":"is-conditional-type-distribution-guard.mjs","sourceRoot":"","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,IAAc,EAAW,EAAE;IAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;IAEhC,IAAI,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE,CAAC;QAC5D,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;IAExC,+EAA+E;IAC/E,4EAA4E;IAC5E,IACE,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;QAC3C,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAC3C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,CACL,SAAS,CAAC,YAAY,KAAK,IAAI,CAAC,YAAY;QAC5C,MAAM,CAAC,cAAc,EAAE,CAAC,YAAY,KAAK,IAAI,CAAC,YAAY,CAC3D,CAAC;AACJ,CAAC,CAAC"}

package/dist/functions/functions/is-readonly-node.mjs

@@ -1,20 +1,126 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { isAtomicTypeNode } from './is-atomic-type-node.mjs';
+export const isShallowReadonlyTypeNode = (node) => isReadonlyTupleOrArrayTypeNode(node) ||
+    isReadonlyTypeReferenceNode(node) ||
+    isAtomicTypeNode(node);
+export const isReadonlyTupleOrArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
+    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+    (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) ||
+        node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
+export const isReadonlyArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
+    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+    node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
 
-const isShallowReadonlyTypeNode = (node) => isReadonlyTupleOrArrayTypeNode(node) || isReadonlyTypeReferenceNode(node) || isAtomicTypeNode(node);
-const isReadonlyTupleOrArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind
-node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
-const isReadonlyArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
-const isReadonlyTupleTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
-const isReadonlyTypeReferenceNode = (node) => {
-  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
-    return false;
-  }
-  const typeName = node.getTypeName();
-  const typeArguments = node.getTypeArguments();
-  return typeName.isKind(tsm.SyntaxKind.Identifier) && typeName.getText() === "Readonly" && Arr.isFixedLengthArray(1, typeArguments);
+const getTypeNodeFromSource = (sourceCode, typeName) => {
+    const project = new tsm.Project({ useInMemoryFileSystem: true });
+    const sourceFile = project.createSourceFile('test.ts', sourceCode);
+    const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);
+    return typeAlias.getTypeNodeOrThrow();
 };
 
-export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode };
-//# sourceMappingURL=is-readonly-node.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isReadonlyTupleTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
+    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isReadonlyTypeReferenceNode = (node) => {
+    if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+        return false;
+    }
+    const typeName = node.getTypeName();
+    const typeArguments = node.getTypeArguments();
+    return (typeName.isKind(tsm.SyntaxKind.Identifier) &&
+        typeName.getText() === 'Readonly' &&
+        Arr.isFixedLengthArray(1, typeArguments));
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=is-readonly-node.mjs.map

package/dist/functions/functions/is-readonly-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-readonly-node.mjs","sources":["../../../src/functions/functions/is-readonly-node.mts"],"sourcesContent":["import { Arr, expectType } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly, type StrictOmit } from 'ts-type-forge';\nimport { isAtomicTypeNode } from './is-atomic-type-node.mjs';\n\nexport const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>\n  isReadonlyTupleOrArrayTypeNode(node) ||\n  isReadonlyTypeReferenceNode(node) ||\n  isAtomicTypeNode(node);\n\nexport const isReadonlyTupleOrArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode | ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind\n    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n\nexport type ReadonlyArrayTypeNode = tsm.TypeNode &\n  StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.ArrayTypeNode;\n  }>;\n\nexport const isReadonlyArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);\n\n// Helper to get a specific type node from source code\nconst getTypeNodeFromSource = (\n  sourceCode: string,\n  typeName: string,\n): tsm.Node => {\n  const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n  const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n  const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);\n\n  return typeAlias.getTypeNodeOrThrow();\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyArrayTypeNode', () => {\n    test('should return true for readonly array type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      if (isReadonlyArrayTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.ArrayTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyArrayTypeNode(node)) {\n        throw new Error('node should be ReadonlyArrayTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType));\n    });\n\n    test('should return false for non-readonly array', () => {\n      const node = getTypeNodeFromSource('type Test = string[];', 'Test');\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n\n    test('should return false for readonly tuple', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [string];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTupleTypeNode = tsm.TypeNode &\n  StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.TupleTypeNode;\n  }>;\n\nexport const isReadonlyTupleTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTupleTypeNode', () => {\n    test('should return true for readonly tuple type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [number, string];',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTupleTypeNode(node));\n\n      if (isReadonlyTupleTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.TupleTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyTupleTypeNode(node)) {\n        throw new Error('node should be ReadonlyTupleTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n    });\n\n    test('should return false for non-readonly tuple', () => {\n      const node = getTypeNodeFromSource('type Test = [boolean];', 'Test');\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n\n    test('should return false for readonly array', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTypeReferenceNode = tsm.TypeNode &\n  StrictOmit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &\n  Readonly<{\n    getTypeName: () => StrictOmit<tsm.Identifier, 'getText'> &\n      Readonly<{\n        getText: () => 'Readonly';\n      }>;\n    getTypeArguments: () => readonly [tsm.TypeNode];\n  }>;\n\nexport const isReadonlyTypeReferenceNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTypeReferenceNode => {\n  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  const typeName = node.getTypeName();\n\n  const typeArguments = node.getTypeArguments();\n\n  return (\n    typeName.isKind(tsm.SyntaxKind.Identifier) &&\n    typeName.getText() === 'Readonly' &&\n    Arr.isFixedLengthArray(1, typeArguments)\n  );\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTypeReferenceNode', () => {\n    test('should return true for Readonly<T>', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Readonly<{ x: number }>;',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTypeReferenceNode(node));\n\n      if (isReadonlyTypeReferenceNode(node)) {\n        const _typeNameText = node.getTypeName().getText();\n\n        expectType<typeof _typeNameText, 'Readonly'>('=');\n\n        const _typeArguments = node.getTypeArguments();\n\n        expectType<\n          typeof _typeArguments,\n          readonly [tsm.TypeNode<tsm.ts.TypeNode>]\n        >('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeReference));\n\n      if (!isReadonlyTypeReferenceNode(node)) {\n        throw new Error('node should be ReadonlyNode');\n      }\n\n      expect(node.getTypeName().getText()).toBe('Readonly');\n\n      expect(node.getTypeArguments()).toHaveLength(1);\n    });\n\n    test('should return false for other type references', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Partial<{ y: string }>;',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly without type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const node = getTypeNodeFromSource('type Test = Readonly;', 'Test');\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly with multiple type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n      // Need to create manually as TS parser might reject Readonly<A, B>\n      const sourceFile = project.createSourceFile(\n        'test.ts',\n        'type Test = Readonly<string, number>;',\n      );\n\n      const node = sourceFile.getTypeAliasOrThrow('Test').getTypeNodeOrThrow();\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n  });\n}\n"],"names":[],"mappings":";;;;MAKa,yBAAA,GAA4B,CAAC,IAAA,KACxC,8BAAA,CAA+B,IAAI,KACnC,2BAAA,CAA4B,IAAI,CAAA,IAChC,gBAAA,CAAiB,IAAI;MAEV,8BAAA,GAAiC,CAC5C,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,KACrC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA;AACjD,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA,CAAO,GAAA,CAAI,WAAW,SAAS,CAAA;MASzC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;MAqEvC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;AA4D7C,MAAM,2BAAA,GAA8B,CACzC,IAAA,KACsC;AACtC,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA,EAAG;AAC9C,IAAA,OAAO,KAAA;AAAA,EAAA;AAGT,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,MAAM,aAAA,GAAgB,KAAK,gBAAA,EAAiB;AAE5C,EAAA,OACE,QAAA,CAAS,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,UAAU,CAAA,IACzC,QAAA,CAAS,OAAA,EAAQ,KAAM,UAAA,IACvB,GAAA,CAAI,kBAAA,CAAmB,GAAG,aAAa,CAAA;AAE3C;;;;"}
+{"version":3,"file":"is-readonly-node.mjs","sourceRoot":"","sources":["../../../src/functions/functions/is-readonly-node.mts"],"names":[],"mappings":"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"}

package/dist/functions/functions/is-spread-parameter-node.mjs

@@ -1,7 +1,6 @@
 import * as tsm from 'ts-morph';
-
-const isSpreadParameterNode = (node) => node.isKind(tsm.SyntaxKind.Parameter) && node.getDotDotDotToken() !== void 0;
-const isSpreadNamedTupleMemberNode = (node) => node.isKind(tsm.SyntaxKind.NamedTupleMember) && node.getDotDotDotToken() !== void 0;
-
-export { isSpreadNamedTupleMemberNode, isSpreadParameterNode };
-//# sourceMappingURL=is-spread-parameter-node.mjs.map
+export const isSpreadParameterNode = (node) => node.isKind(tsm.SyntaxKind.Parameter) &&
+    node.getDotDotDotToken() !== undefined;
+export const isSpreadNamedTupleMemberNode = (node) => node.isKind(tsm.SyntaxKind.NamedTupleMember) &&
+    node.getDotDotDotToken() !== undefined;
+//# sourceMappingURL=is-spread-parameter-node.mjs.map

package/dist/functions/functions/is-spread-parameter-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-spread-parameter-node.mjs","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\nexport const isSpreadParameterNode = (\n  node: tsm.Node,\n): node is tsm.ParameterDeclaration =>\n  node.isKind(tsm.SyntaxKind.Parameter) &&\n  node.getDotDotDotToken() !== undefined;\n\nexport const isSpreadNamedTupleMemberNode = (\n  node: tsm.Node,\n): node is tsm.NamedTupleMember =>\n  node.isKind(tsm.SyntaxKind.NamedTupleMember) &&\n  node.getDotDotDotToken() !== undefined;\n"],"names":[],"mappings":";;AAEO,MAAM,qBAAA,GAAwB,CACnC,IAAA,KAEA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,IACpC,IAAA,CAAK,iBAAA,EAAkB,KAAM;AAExB,MAAM,4BAAA,GAA+B,CAC1C,IAAA,KAEA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,gBAAgB,CAAA,IAC3C,IAAA,CAAK,iBAAA,EAAkB,KAAM;;;;"}
+{"version":3,"file":"is-spread-parameter-node.mjs","sourceRoot":"","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,IAAc,EACoB,EAAE,CACpC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;IACrC,IAAI,CAAC,iBAAiB,EAAE,KAAK,SAAS,CAAC;AAEzC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,IAAc,EACgB,EAAE,CAChC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC5C,IAAI,CAAC,iBAAiB,EAAE,KAAK,SAAS,CAAC"}

package/dist/functions/functions/remove-parentheses.mjs

@@ -1,6 +1,6 @@
 import * as tsm from 'ts-morph';
 
-const removeParentheses = (node) => node.isKind(tsm.SyntaxKind.ParenthesizedType) ? removeParentheses(node.getTypeNode()) : node;
-
-export { removeParentheses };
-//# sourceMappingURL=remove-parentheses.mjs.map
+export const removeParentheses = (node) => node.isKind(tsm.SyntaxKind.ParenthesizedType)
+    ? removeParentheses(node.getTypeNode())
+    : node;
+//# sourceMappingURL=remove-parentheses.mjs.map

package/dist/functions/functions/remove-parentheses.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"remove-parentheses.mjs","sources":["../../../src/functions/functions/remove-parentheses.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nexport const removeParentheses = (node: tsm.TypeNode): tsm.TypeNode =>\n  node.isKind(tsm.SyntaxKind.ParenthesizedType)\n    ? removeParentheses(node.getTypeNode())\n    : node;\n"],"names":[],"mappings":";;AAGO,MAAM,iBAAA,GAAoB,CAAC,IAAA,KAChC,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,iBAAiB,CAAA,GACxC,iBAAA,CAAkB,IAAA,CAAK,WAAA,EAAa,CAAA,GACpC;;;;"}
+{"version":3,"file":"remove-parentheses.mjs","sourceRoot":"","sources":["../../../src/functions/functions/remove-parentheses.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,8EAA8E;AAC9E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAkB,EAAgB,EAAE,CACpE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,iBAAiB,CAAC;IAC3C,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IACvC,CAAC,CAAC,IAAI,CAAC"}

package/dist/functions/functions/should-avoid-parentheses-for-readonly.mjs

@@ -1,12 +1,26 @@
 import * as tsm from 'ts-morph';
 
-const shouldAvoidParenthesesForReadonly = (node) => {
-  const parent = node.getParent();
-  if (parent === void 0) {
-    return false;
-  }
-  return parent.isKind(tsm.SyntaxKind.TypePredicate);
-};
 
-export { shouldAvoidParenthesesForReadonly };
-//# sourceMappingURL=should-avoid-parentheses-for-readonly.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+export const shouldAvoidParenthesesForReadonly = (node) => {
+    const parent = node.getParent();
+    if (parent === undefined) {
+        return false;
+    }
+
+
+
+
+    return parent.isKind(tsm.SyntaxKind.TypePredicate);
+};
+//# sourceMappingURL=should-avoid-parentheses-for-readonly.mjs.map

package/dist/functions/functions/should-avoid-parentheses-for-readonly.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"should-avoid-parentheses-for-readonly.mjs","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n/**\n * Determines if parentheses should be avoided when adding 'readonly' prefix to a type.\n *\n * Parentheses should be AVOIDED in these specific contexts:\n * - Type predicates: `x is [T, U]` -> `x is readonly [T, U]` (not `x is (readonly [T, U])`)\n *   because parentheses around the type in a type predicate cause syntax errors\n *\n * For all other contexts, we keep parentheses for safety to avoid precedence issues,\n * relying on prettier to remove unnecessary ones.\n *\n * @param node - The type node to check\n * @returns true if parentheses should be avoided, false otherwise (keep parentheses)\n */\nexport const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {\n  const parent = node.getParent();\n\n  if (parent === undefined) {\n    return false;\n  }\n\n  // Check if parent is TypePredicate: x is T\n  // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))\n  // because `x is (readonly T)` is a syntax error\n  // For all other cases, keep parentheses for safety\n  return parent.isKind(tsm.SyntaxKind.TypePredicate);\n};\n"],"names":[],"mappings":";;AAeO,MAAM,iCAAA,GAAoC,CAAC,IAAA,KAA4B;AAC5E,EAAA,MAAM,MAAA,GAAS,KAAK,SAAA,EAAU;AAE9B,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,KAAA;AAAA,EACT;AAMA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA;AACnD;;;;"}
+{"version":3,"file":"should-avoid-parentheses-for-readonly.mjs","sourceRoot":"","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,IAAc,EAAW,EAAE;IAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;IAEhC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,2CAA2C;IAC3C,mFAAmF;IACnF,gDAAgD;IAChD,mDAAmD;IACnD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC,CAAC"}

package/dist/functions/functions/unwrap-readonly.mjs

@@ -1,6 +1,5 @@
 import { wrapWithParentheses } from './wrap-with-parentheses.mjs';
+export const unwrapReadonlyTypeArgText = (
 
-const unwrapReadonlyTypeArgText = (node) => wrapWithParentheses(node.getTypeArguments()[0].getFullText());
-
-export { unwrapReadonlyTypeArgText };
-//# sourceMappingURL=unwrap-readonly.mjs.map
+node) => wrapWithParentheses(node.getTypeArguments()[0].getFullText());
+//# sourceMappingURL=unwrap-readonly.mjs.map