ts-const-value-transformer 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.6.0
+
+- Remove skipping satisfies expression
+- Accept `undefined` for `context` and remove dependencies for `context`
+- Fix referring `ts` instance and add `ts` parameter for printSource
+- Add cache to createPortalTransformer
+- Add `recreateProgramOnTransformCount` option for PortalTransformer
+- Fix to use `createPortalTransformerSync` for webpack loader
+- Search tsconfig before loading
+
+## v0.5.1
+
+- Fix missing for handling `ignoreFiles` for `createTransformer` (used from ts-loader, etc.)
+
 ## v0.5.0
 
 - Add `useUndefinedSymbolForUndefinedValue` and `hoistUndefinedSymbol` options

package/README.md

@@ -264,6 +264,8 @@ Prints (generates) source code from `SourceFile`, along with raw source-map data
 
 Transforms the source file with TypeScript project. You don't need to call this function directly; use `createTransformer` or `createPortalTransformer` instead.
 
+Note that `ignoreFiles` of `options` will be ignored for this function.
+
 #### version: string
 
 The version string of this package.
@@ -277,7 +279,24 @@ See [Transform options](#transform-options).
 Creates 'portal transformer', which can be used the transformer easily from the code which does not use TypeScript Compiler API.  
 The return object has `transform` method with signature: `(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions) => [newSource: string, newSourceMap: RawSourceMap | undefined]`. You can call to transform TypeScript source code. (Note that this API does not transpile to JavaScript; the output code is still TypeScript code.)
 
-`CreatePortalTransformerOptions` has three optional options: `project` (path to tsconfig.json), `typescript` (package path to `typescript` or `typescript` namespace object), and `cwd` (current directory for file search). Also, `ignoreFiles` can be used.
+`CreatePortalTransformerOptions` has a following signature. Also, `ignoreFiles` of `TransformOptions` can be used.
+
+```ts
+interface CreatePortalTransformerOptions extends TransformOptions {
+  /** Path to tsconfig.json. If omitted, `tsconfig.json` will be used. */
+  project?: string;
+  /** Package path to `typescript` or `typescript` namespace object. */
+  typescript?: string | typeof tsNamespace;
+  /** The current directory for file search. Also affects to `project` option. */
+  cwd?: string;
+  /**
+   * Speficies the count. When the transformation count reaches this value, `program` instance will be recreated (and count will be reset).
+   * This is useful if the project is big and out-of-memory occurs during transformation, but the process may be slower.
+   * If 0 or `undefined`, recreation will not be performed.
+   */
+  recreateProgramOnTransformCount?: number;
+}
+```
 
 If `Promise` cannot be used for some reason, use `createPortalTransformerSync` instead.
 

package/dist/createPortalTransformer.d.mts

@@ -2,15 +2,28 @@ import type { RawSourceMap } from 'source-map';
 import type * as tsNamespace from 'typescript';
 import { type TransformOptions } from './transform.mjs';
 export interface CreatePortalTransformerOptions extends TransformOptions {
+    /** Path to tsconfig.json. If omitted, `tsconfig.json` will be used. */
     project?: string;
+    /** Package path to `typescript` or `typescript` namespace object. */
     typescript?: string | typeof tsNamespace;
+    /** The current directory for file search. Also affects to `project` option. */
     cwd?: string;
+    /**
+     * Speficies the count. When the transformation count reaches this value, `program` instance will be recreated (and count will be reset).
+     * This is useful if the project is big and out-of-memory occurs during transformation, but the process may be slower.
+     * If 0 or `undefined`, recreation will not be performed.
+     */
+    recreateProgramOnTransformCount?: number;
 }
 export interface PortalTransformer {
     /** The `typescript` namespace object */
     readonly ts: typeof tsNamespace;
     /** Active `Program` instance for the transformer */
     readonly program: tsNamespace.Program;
+    /** Clears transformed cache. */
+    clearCache(): void;
+    /** Forces `program` recreation. The transformation count for `recreateProgramOnTransformCount` will also be resetted. */
+    recreateProgram(): void;
     /**
      * Performs transformation.
      * @param content Base source code. If null, uses loaded source code in the TS project.

package/dist/createPortalTransformer.mjs

@@ -2,27 +2,31 @@ import * as fs from 'fs';
 import { createRequire } from 'module';
 import * as path from 'path';
 import createTransformer from './createTransformer.mjs';
-import { printSourceWithMap } from './transform.mjs';
+import { getIgnoreFilesFunction, printSourceWithMap, } from './transform.mjs';
 const require = createRequire(import.meta.url);
+function optionsToString(options) {
+    return JSON.stringify(options, (key, value) => {
+        if (typeof value === 'function' || value instanceof RegExp) {
+            return value.toString();
+        }
+        if (key === 'typescript' && typeof value === 'object' && value != null) {
+            return '[object typescript]';
+        }
+        return value;
+    });
+}
 function createPortalTransformerImpl(options, ts) {
     const project = options.project ?? 'tsconfig.json';
-    let ignoreFiles = options.ignoreFiles ?? [];
-    if (typeof ignoreFiles !== 'function') {
-        const a = ignoreFiles;
-        ignoreFiles = (fileName) => {
-            return a.some((t) => {
-                if (typeof t === 'string') {
-                    return fileName.indexOf(t) >= 0;
-                }
-                else {
-                    return t.test(fileName);
-                }
-            });
-        };
-    }
+    const ignoreFiles = getIgnoreFilesFunction(options.ignoreFiles);
     const cwd = options.cwd ?? process.cwd();
+    const recreateProgramOnTransformCount = options.recreateProgramOnTransformCount ?? 0;
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const foundConfigPath = ts.findConfigFile(cwd, ts.sys.fileExists, project);
+    if (foundConfigPath == null) {
+        throw new Error(`[ts-const-value-transformer] Unable to load tsconfig file (effective name = '${project}')`);
+    }
     const getCurrentDirectory = () => cwd;
-    const config = ts.getParsedCommandLineOfConfigFile(project, void 0, {
+    const config = ts.getParsedCommandLineOfConfigFile(foundConfigPath, void 0, {
         fileExists: fs.existsSync,
         getCurrentDirectory,
         // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -38,16 +42,37 @@ function createPortalTransformerImpl(options, ts) {
         },
     });
     if (!config) {
-        throw new Error(`[ts-const-value-transformer] Unable to load tsconfig file (effective name = '${project}')`);
+        throw new Error(`[ts-const-value-transformer] Unable to load tsconfig file (effective name = '${foundConfigPath}')`);
     }
-    const program = ts.createProgram({
+    let program = ts.createProgram({
         options: config.options,
         rootNames: config.fileNames,
     });
-    return {
+    let transformationCount = 0;
+    const recreateProgram = () => {
+        const oldProgram = program;
+        program = ts.createProgram({
+            options: config.options,
+            rootNames: config.fileNames,
+            oldProgram,
+        });
+        instance.program = program;
+        transformationCount = 0;
+    };
+    const cache = new Map();
+    const instance = {
         ts,
         program,
+        clearCache: () => cache.clear(),
+        recreateProgram,
         transform: (content, fileName, sourceMap, individualOptions) => {
+            const individualOptionsJson = optionsToString(individualOptions ?? {});
+            const cachedData = cache.get(fileName);
+            if (cachedData &&
+                cachedData.content === content &&
+                cachedData.optJson === individualOptionsJson) {
+                return cachedData.result;
+            }
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const rawSourceMap = typeof sourceMap === 'string'
                 ? JSON.parse(sourceMap)
@@ -55,30 +80,38 @@ function createPortalTransformerImpl(options, ts) {
             if (ignoreFiles(fileName)) {
                 return [content, rawSourceMap];
             }
+            transformationCount++;
+            if (recreateProgramOnTransformCount > 0 &&
+                transformationCount >= recreateProgramOnTransformCount) {
+                recreateProgram();
+            }
             const sourceFile = program.getSourceFile(fileName);
             if (!sourceFile) {
                 return [content, rawSourceMap];
             }
             // If input content is changed, replace it
-            if (content != null && sourceFile.getFullText() !== content) {
+            if (content != null && sourceFile.text !== content) {
                 sourceFile.update(content, {
                     span: { start: 0, length: sourceFile.end },
                     newLength: content.length,
                 });
+                sourceFile.text = content;
             }
             const transformer = createTransformer(program, {
                 options: { ...options, ...individualOptions, ts },
             });
-            const result = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
-            const transformedSource = result.transformed[0];
+            const transformResult = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
+            const transformedSource = transformResult.transformed[0];
             // If unchanged, return base file as-is
             if (transformedSource === sourceFile) {
-                return [content ?? sourceFile.getFullText(), rawSourceMap];
+                return [content ?? sourceFile.text, rawSourceMap];
             }
-            const printed = printSourceWithMap(transformedSource, fileName, rawSourceMap);
-            return printed;
+            const result = printSourceWithMap(transformedSource, fileName, rawSourceMap, ts);
+            cache.set(fileName, { content, optJson: individualOptionsJson, result });
+            return result;
         },
     };
+    return instance;
 }
 /**
  * Creates the new portal transformer instance for the TS project.

package/dist/createTransformer.d.mts

@@ -3,7 +3,8 @@ import { type TransformOptions } from './transform.mjs';
 interface Config {
     options?: TransformOptions;
 }
+export type TransformerFactory = (context?: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
 export default function createTransformer(program: ts.Program, config?: Config, extras?: {
     ts?: typeof ts;
-}): ts.TransformerFactory<ts.SourceFile>;
+}): TransformerFactory;
 export {};

package/dist/createTransformer.mjs

@@ -1,15 +1,20 @@
-import { transformSource } from './transform.mjs';
+import { getIgnoreFilesFunction, transformSource, } from './transform.mjs';
 export default function createTransformer(program, 
 // for ttypescript and ts-patch
 config, 
 // for ts-patch
 extras) {
-    return (context) => {
+    const options = {
+        ...config?.options,
+        ...(extras?.ts && { ts: extras?.ts }),
+    };
+    const ignoreFiles = getIgnoreFilesFunction(options.ignoreFiles);
+    return ((context) => {
         return (sourceFile) => {
-            return transformSource(sourceFile, program, context, {
-                ...config?.options,
-                ...(extras?.ts && { ts: extras?.ts }),
-            });
+            if (ignoreFiles(sourceFile.fileName)) {
+                return sourceFile;
+            }
+            return transformSource(sourceFile, program, context, options);
         };
-    };
+    });
 }

package/dist/loader.d.mts

@@ -1,9 +1,5 @@
-import type * as tsNamespace from 'typescript';
 import type * as webpack from 'webpack';
-import type { TransformOptions } from './transform.mjs';
-export interface TsConstValueTransformerLoaderOptions extends TransformOptions {
-    project?: string;
-    typescript?: string | typeof tsNamespace;
-}
+import { type CreatePortalTransformerOptions } from './createPortalTransformer.mjs';
+export type TsConstValueTransformerLoaderOptions = CreatePortalTransformerOptions;
 declare const loader: webpack.LoaderDefinitionFunction<TsConstValueTransformerLoaderOptions | undefined>;
 export default loader;

package/dist/loader.mjs

@@ -1,17 +1,19 @@
 import * as path from 'path';
-import createPortalTransformer, {} from './createPortalTransformer.mjs';
+import { createPortalTransformerSync, } from './createPortalTransformer.mjs';
 const transformerMap = new Map();
 const loader = function (content, sourceMap) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions, @typescript-eslint/strict-boolean-expressions
+    this.cacheable && this.cacheable();
     this.async();
-    void (async () => {
+    void Promise.resolve().then(() => {
         try {
             const options = this.getOptions() || {};
             const project = options.project ?? 'tsconfig.json';
             let transformer = transformerMap.get(project);
             if (!transformer) {
-                transformer = await createPortalTransformer({
-                    ...options,
+                transformer = createPortalTransformerSync({
                     cwd: path.dirname(this.resourcePath),
+                    ...options,
                 });
                 transformerMap.set(project, transformer);
             }
@@ -21,6 +23,6 @@ const loader = function (content, sourceMap) {
         catch (e) {
             this.callback(e);
         }
-    })();
+    });
 };
 export default loader;

package/dist/transform.d.mts

@@ -1,5 +1,5 @@
 import * as sourceMap from 'source-map';
-import * as ts from 'typescript';
+import type * as ts from 'typescript';
 export interface TransformOptions {
     /** `typescript` namespace object */
     ts?: typeof ts;
@@ -35,6 +35,7 @@ export interface TransformOptions {
      */
     ignoreFiles?: ReadonlyArray<string | RegExp> | ((fileName: string) => boolean);
 }
-export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext, options?: TransformOptions): ts.SourceFile;
-export declare function printSource(sourceFile: ts.SourceFile): string;
-export declare function printSourceWithMap(sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];
+export declare function getIgnoreFilesFunction(ignoreFiles: TransformOptions['ignoreFiles']): (fileName: string) => boolean;
+export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions): ts.SourceFile;
+export declare function printSource(sourceFile: ts.SourceFile, tsInstance?: typeof ts): string;
+export declare function printSourceWithMap(sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: sourceMap.RawSourceMap, tsInstance?: typeof ts): [string, sourceMap.RawSourceMap];

package/dist/transform.mjs

@@ -1,10 +1,10 @@
 import * as sourceMap from 'source-map';
-import * as ts from 'typescript';
+import * as tsNamespace from 'typescript';
 const SYMBOL_ORIGINAL_NODE = Symbol('originalNode');
 function assignDefaultValues(options = {}) {
     return {
         // avoid using spread syntax to override `undefined` (not missing) values
-        ts: options.ts ?? ts,
+        ts: options.ts ?? tsNamespace,
         hoistProperty: options.hoistProperty ?? true,
         hoistEnumValues: options.hoistEnumValues ?? true,
         hoistExternalValues: options.hoistExternalValues ?? true,
@@ -19,18 +19,36 @@ function assignDefaultValues(options = {}) {
     };
 }
 ////////////////////////////////////////////////////////////////////////////////
+export function getIgnoreFilesFunction(ignoreFiles) {
+    if (!ignoreFiles) {
+        return () => false;
+    }
+    if (typeof ignoreFiles === 'function') {
+        return ignoreFiles;
+    }
+    const a = ignoreFiles;
+    return (fileName) => {
+        return a.some((t) => {
+            if (typeof t === 'string') {
+                return fileName.indexOf(t) >= 0;
+            }
+            else {
+                return t.test(fileName);
+            }
+        });
+    };
+}
+////////////////////////////////////////////////////////////////////////////////
 export function transformSource(sourceFile, program, context, options) {
-    return visitNodeChildren(sourceFile, sourceFile, sourceFile, program, context, assignDefaultValues(options));
+    const requiredOptions = assignDefaultValues(options);
+    return requiredOptions.ts.visitEachChild(sourceFile, (node) => visitNodeChildren(node, sourceFile, sourceFile, program, requiredOptions), context);
 }
-function visitNodeChildren(node, parent, sourceFile, program, context, options) {
-    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context, options);
+function visitNodeChildren(node, parent, sourceFile, program, options) {
+    const ts = options.ts;
+    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options);
     if (newNode[SYMBOL_ORIGINAL_NODE]) {
         return newNode;
     }
-    // skip children for satisifes expression
-    if (ts.isSatisfiesExpression(newNode)) {
-        return newNode;
-    }
     // skip statements which would not have 'value' expressions
     if (ts.isInterfaceDeclaration(newNode) ||
         ts.isTypeAliasDeclaration(newNode) ||
@@ -39,9 +57,9 @@ function visitNodeChildren(node, parent, sourceFile, program, context, options)
         ts.isTypeOnlyExportDeclaration(newNode)) {
         return newNode;
     }
-    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, newNode, sourceFile, program, context, options), context);
+    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, newNode, sourceFile, program, options), void 0);
 }
-function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context, options) {
+function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options) {
     const ts = options.ts;
     if (ts.isCallLikeExpression(node)) {
         if (!ts.isExpression(node) ||
@@ -87,12 +105,11 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context,
         return node;
     }
     if (!options.hoistExternalValues &&
-        isExternalReference(node, program, options.externalNames)) {
+        isExternalReference(node, program, options.externalNames, ts)) {
         return node;
     }
     if (!options.unsafeHoistAsExpresion &&
-        (hasAsExpression(node, context, ts) ||
-            hasParentAsExpression(parent, context, ts))) {
+        (hasAsExpression(node, ts) || hasParentAsExpression(parent, ts))) {
         return node;
     }
     if (!options.unsafeHoistWritableValues) {
@@ -110,35 +127,33 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context,
             return node;
         }
         if (type.isStringLiteral()) {
-            newNode = context.factory.createStringLiteral(type.value);
+            newNode = ts.factory.createStringLiteral(type.value);
         }
         else if (type.isNumberLiteral()) {
             if (type.value < 0) {
-                newNode = context.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, context.factory.createNumericLiteral(-type.value));
+                newNode = ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-type.value));
             }
             else {
-                newNode = context.factory.createNumericLiteral(type.value);
+                newNode = ts.factory.createNumericLiteral(type.value);
             }
         }
         else if (flags & ts.TypeFlags.BigIntLiteral) {
-            newNode = context.factory.createBigIntLiteral(typeChecker.typeToString(type));
+            newNode = ts.factory.createBigIntLiteral(typeChecker.typeToString(type));
         }
         else if (flags & ts.TypeFlags.BooleanLiteral) {
             const text = typeChecker.typeToString(type);
             newNode =
-                text === 'true'
-                    ? context.factory.createTrue()
-                    : context.factory.createFalse();
+                text === 'true' ? ts.factory.createTrue() : ts.factory.createFalse();
         }
         else if (flags & ts.TypeFlags.Null) {
-            newNode = context.factory.createNull();
+            newNode = ts.factory.createNull();
         }
         else if (flags & ts.TypeFlags.Undefined) {
             if (options.useUndefinedSymbolForUndefinedValue) {
-                newNode = context.factory.createIdentifier('undefined');
+                newNode = ts.factory.createIdentifier('undefined');
             }
             else {
-                newNode = context.factory.createVoidZero();
+                newNode = ts.factory.createVoidZero();
             }
         }
         else {
@@ -165,7 +180,8 @@ function isEnumIdentifier(node, program, tsInstance) {
     const type = typeChecker.getTypeAtLocation(node);
     return (type.getFlags() & ts.TypeFlags.EnumLiteral) !== 0;
 }
-function isExternalReference(node, program, externalNames) {
+function isExternalReference(node, program, externalNames, tsInstance) {
+    const ts = tsInstance;
     const typeChecker = program.getTypeChecker();
     const nodeSym = typeChecker.getSymbolAtLocation(node);
     let nodeFrom = nodeSym?.getDeclarations()?.[0];
@@ -218,7 +234,7 @@ function isExternalReference(node, program, externalNames) {
 function isAsConstExpression(node) {
     return node.type.getText() === 'const';
 }
-function hasAsExpression(node, context, tsInstance) {
+function hasAsExpression(node, tsInstance) {
     const ts = tsInstance;
     // including 'as const'
     if (ts.isAsExpression(node)) {
@@ -227,13 +243,13 @@ function hasAsExpression(node, context, tsInstance) {
     let found = false;
     ts.visitEachChild(node, (node) => {
         if (!found) {
-            found = hasAsExpression(node, context, ts);
+            found = hasAsExpression(node, ts);
         }
         return node;
-    }, context);
+    }, void 0);
     return found;
 }
-function hasParentAsExpression(node, context, tsInstance) {
+function hasParentAsExpression(node, tsInstance) {
     const ts = tsInstance;
     if (node == null) {
         return false;
@@ -244,11 +260,11 @@ function hasParentAsExpression(node, context, tsInstance) {
     }
     if (ts.isPropertyAccessExpression(node) ||
         ts.isElementAccessExpression(node)) {
-        if (hasAsExpression(node.expression, context, ts)) {
+        if (hasAsExpression(node.expression, ts)) {
             return true;
         }
     }
-    return hasParentAsExpression(node.parent, context, ts);
+    return hasParentAsExpression(node.parent, ts);
 }
 function hasPureAnnotation(node, sourceFile, tsInstance) {
     const ts = tsInstance;
@@ -388,19 +404,19 @@ function isUndefinedIdentifier(node, parent, program, tsInstance) {
         return false;
     }
     if (type.isUnionOrIntersection() ||
-        !(type.getFlags() & ts.TypeFlags.Undefined)) {
+        !(type.getFlags() & tsInstance.TypeFlags.Undefined)) {
         return false;
     }
     return true;
 }
 ////////////////////////////////////////////////////////////////////////////////
-export function printSource(sourceFile) {
-    return printSourceImpl(sourceFile)[0];
+export function printSource(sourceFile, tsInstance) {
+    return printSourceImpl(tsInstance, sourceFile)[0];
 }
-export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap) {
+export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap, tsInstance) {
     const generator = new sourceMap.SourceMapGenerator(startOfSourceMap);
     generator.setSourceContent(originalSourceName, sourceFile.getFullText());
-    return printSourceImpl(sourceFile, originalSourceName, generator);
+    return printSourceImpl(tsInstance, sourceFile, originalSourceName, generator);
 }
 function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
     let line = 0;
@@ -414,16 +430,17 @@ function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
     }
     return { line, column: pos - lastLinePos + generatedDiff };
 }
-function printSourceImpl(sourceFile, originalSourceName, mapGenerator) {
+function printSourceImpl(tsInstance, sourceFile, originalSourceName, mapGenerator) {
+    const ts = tsInstance ?? tsNamespace;
     const printer = ts.createPrinter({ removeComments: true });
-    const r = printNode(printer, sourceFile.getFullText(), sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
+    const r = printNode(ts, printer, sourceFile.getFullText(), sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
     return [r, mapGenerator?.toJSON()];
 }
-function printNode(printer, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
+function printNode(tsInstance, printer, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
     const originalNode = node[SYMBOL_ORIGINAL_NODE];
     if (originalNode) {
-        let result = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
-        const comments = ts.getSyntheticTrailingComments(node);
+        let result = printer.printNode(tsInstance.EmitHint.Unspecified, node, sourceFile);
+        const comments = tsInstance.getSyntheticTrailingComments(node);
         if (comments) {
             for (const comment of comments) {
                 result += ` /*${comment.text}*/`;
@@ -457,7 +474,7 @@ function printNode(printer, baseSource, sourceFile, node, posContext, originalSo
     let output = '';
     let headPrinted = false;
     let lastChildPos = 0;
-    ts.visitEachChild(node, (child) => {
+    tsInstance.visitEachChild(node, (child) => {
         if (!headPrinted) {
             headPrinted = true;
             if (child.pos > node.pos) {
@@ -473,7 +490,7 @@ function printNode(printer, baseSource, sourceFile, node, posContext, originalSo
             addMappingForCurrent();
             posContext.pos = child.pos;
         }
-        output += printNode(printer, baseSource, sourceFile, child, posContext, originalSourceName, mapGenerator);
+        output += printNode(tsInstance, printer, baseSource, sourceFile, child, posContext, originalSourceName, mapGenerator);
         lastChildPos = child.end;
         return child;
     }, void 0);

package/dist/version.d.mts

@@ -1,2 +1,2 @@
-declare const _default: "0.5.0";
+declare const _default: "0.6.0";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.5.0';
+export default '0.6.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-const-value-transformer",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "engines": {
     "node": ">=20.19.3"
   },