ts-const-value-transformer 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v0.7.0
+
+- Fix for printing 'minus numeric value' and 'void 0', and remove using `ts.createPrinter`
+- Fix that `recreateProgram` creates the new fresh program instead of passing `oldProgram`
+- Fix to cache source code with no transformation
+- Add option to disable caching original source content (changed to false by default)
+- Fix some codes for better memory usage
+
+## 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.)

package/README.md

@@ -279,7 +279,26 @@ 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;
+  /** Specifies to cache base (original) source code for check if the input is changed. Default is false. */
+  cacheBaseSource?: boolean;
+}
+```
 
 If `Promise` cannot be used for some reason, use `createPortalTransformerSync` instead.
 

package/dist/createPortalTransformer.d.mts

@@ -2,15 +2,38 @@ 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;
+    /**
+     * Specifies 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;
+    /** Specifies to cache base (original) source code for check if the input is changed. Default is false. */
+    cacheBaseSource?: boolean;
 }
+export type PortalTransformerResult = [
+    newSource: string | null,
+    newSourceMap: RawSourceMap | undefined
+];
+export type PortalTransformerResultNonNull = [
+    newSource: string,
+    newSourceMap: RawSourceMap | undefined
+];
 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.
@@ -19,7 +42,7 @@ export interface PortalTransformer {
      * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
      * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
      */
-    transform(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): [newSource: string, newSourceMap: RawSourceMap | undefined];
+    transform(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): PortalTransformerResultNonNull;
     /**
      * Performs transformation.
      * @param content Base source code. If null, uses loaded source code in the TS project.
@@ -28,7 +51,7 @@ export interface PortalTransformer {
      * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
      * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
      */
-    transform(content: string | null, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): [newSource: string | null, newSourceMap: RawSourceMap | undefined];
+    transform(content: string | null, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): PortalTransformerResult;
 }
 /**
  * Creates the new portal transformer instance for the TS project.

package/dist/createPortalTransformer.mjs

@@ -4,12 +4,30 @@ import * as path from 'path';
 import createTransformer from './createTransformer.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';
     const ignoreFiles = getIgnoreFilesFunction(options.ignoreFiles);
     const cwd = options.cwd ?? process.cwd();
+    const recreateProgramOnTransformCount = options.recreateProgramOnTransformCount ?? 0;
+    const cacheBaseSource = options.cacheBaseSource ?? false;
+    // 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
@@ -25,16 +43,41 @@ 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 = () => {
+        // @ts-expect-error: We must clear reference first to give change for gc
+        delete instance.program;
+        // @ts-expect-error: We must clear reference first to give change for gc
+        program = null;
+        // We don't pass `oldProgram` because the transformed source codes should not be necessary (the transformation does not change logics and types)
+        // If we pass `oldProgram`, temporal memory usage may increase because gc cannot release `oldProgram` before creating new program
+        program = ts.createProgram({
+            options: config.options,
+            rootNames: config.fileNames,
+        });
+        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 &&
+                (!cacheBaseSource || 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)
@@ -46,26 +89,41 @@ function createPortalTransformerImpl(options, ts) {
             if (!sourceFile) {
                 return [content, rawSourceMap];
             }
+            transformationCount++;
+            if (recreateProgramOnTransformCount > 0 &&
+                transformationCount >= recreateProgramOnTransformCount) {
+                recreateProgram();
+            }
             // 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];
+            let result;
             // If unchanged, return base file as-is
             if (transformedSource === sourceFile) {
-                return [content ?? sourceFile.getFullText(), rawSourceMap];
+                result = [content ?? sourceFile.text, rawSourceMap];
+            }
+            else {
+                result = printSourceWithMap(transformedSource, fileName, rawSourceMap, ts);
             }
-            const printed = printSourceWithMap(transformedSource, fileName, rawSourceMap);
-            return printed;
+            cache.set(fileName, {
+                content: cacheBaseSource ? 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

@@ -9,12 +9,12 @@ extras) {
         ...(extras?.ts && { ts: extras?.ts }),
     };
     const ignoreFiles = getIgnoreFilesFunction(options.ignoreFiles);
-    return (context) => {
+    return ((context) => {
         return (sourceFile) => {
             if (ignoreFiles(sourceFile.fileName)) {
                 return sourceFile;
             }
             return transformSource(sourceFile, program, context, options);
         };
-    };
+    });
 }

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import createPortalTransformer, { createPortalTransformerSync, type CreatePortalTransformerOptions, type PortalTransformer } from './createPortalTransformer.mjs';
+import createPortalTransformer, { createPortalTransformerSync, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull } from './createPortalTransformer.mjs';
 import createTransformer from './createTransformer.mjs';
 import version from './version.mjs';
 export { printSource, printSourceWithMap, transformSource, type TransformOptions, } from './transform.mjs';
-export { createPortalTransformer, createPortalTransformerSync, createTransformer, type CreatePortalTransformerOptions, type PortalTransformer, version, };
+export { createPortalTransformer, createPortalTransformerSync, createTransformer, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull, version, };

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;
@@ -36,6 +36,6 @@ export interface TransformOptions {
     ignoreFiles?: ReadonlyArray<string | RegExp> | ((fileName: string) => boolean);
 }
 export declare function getIgnoreFilesFunction(ignoreFiles: TransformOptions['ignoreFiles']): (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 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';
-const SYMBOL_ORIGINAL_NODE = Symbol('originalNode');
+import * as tsNamespace from 'typescript';
+const SYMBOL_ORIGINAL_NODE_DATA = Symbol('originalNodeData');
 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,
@@ -40,15 +40,13 @@ export function getIgnoreFilesFunction(ignoreFiles) {
 }
 ////////////////////////////////////////////////////////////////////////////////
 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);
-    if (newNode[SYMBOL_ORIGINAL_NODE]) {
-        return newNode;
-    }
-    // skip children for satisifes expression
-    if (ts.isSatisfiesExpression(newNode)) {
+function visitNodeChildren(node, parent, sourceFile, program, options) {
+    const ts = options.ts;
+    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options);
+    if (newNode[SYMBOL_ORIGINAL_NODE_DATA]) {
         return newNode;
     }
     // skip statements which would not have 'value' expressions
@@ -59,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) ||
@@ -107,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) {
@@ -129,36 +126,50 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context,
         if (type.isUnionOrIntersection()) {
             return node;
         }
+        let newSource;
         if (type.isStringLiteral()) {
-            newNode = context.factory.createStringLiteral(type.value);
+            newNode = ts.factory.createStringLiteral(type.value);
+            newSource =
+                // TypeScript namespace may export `function escapeNonAsciiString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote | CharacterCodes.backtick): string`
+                'escapeNonAsciiString' in ts
+                    ? `"${ts.escapeNonAsciiString(type.value, 'CharacterCodes' in ts
+                        ? ts.CharacterCodes.doubleQuote
+                        : 34 /* doubleQuote */)}"`
+                    : JSON.stringify(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.createParenthesizedExpression(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-type.value)));
+                newSource = `(-${-type.value})`;
             }
             else {
-                newNode = context.factory.createNumericLiteral(type.value);
+                newNode = ts.factory.createNumericLiteral(type.value);
+                newSource = `${type.value}`;
             }
         }
         else if (flags & ts.TypeFlags.BigIntLiteral) {
-            newNode = context.factory.createBigIntLiteral(typeChecker.typeToString(type));
+            const text = typeChecker.typeToString(type);
+            newNode = ts.factory.createBigIntLiteral(text);
+            newSource = text;
         }
         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();
+            newSource = text;
         }
         else if (flags & ts.TypeFlags.Null) {
-            newNode = context.factory.createNull();
+            newNode = ts.factory.createNull();
+            newSource = 'null';
         }
         else if (flags & ts.TypeFlags.Undefined) {
             if (options.useUndefinedSymbolForUndefinedValue) {
-                newNode = context.factory.createIdentifier('undefined');
+                newNode = ts.factory.createIdentifier('undefined');
+                newSource = 'undefined';
             }
             else {
-                newNode = context.factory.createVoidZero();
+                newNode = ts.factory.createParenthesizedExpression(ts.factory.createVoidZero());
+                newSource = '(void 0)';
             }
         }
         else {
@@ -166,7 +177,12 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context,
         }
         const result = ts.addSyntheticTrailingComment(newNode, ts.SyntaxKind.MultiLineCommentTrivia, ` ${node.getText(sourceFile)} `);
         ts.setTextRange(result, node);
-        result[SYMBOL_ORIGINAL_NODE] = node;
+        result[SYMBOL_ORIGINAL_NODE_DATA] = [
+            node.getText(sourceFile),
+            newSource,
+            node.pos,
+            node.end,
+        ];
         return result;
     }
     catch {
@@ -185,7 +201,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];
@@ -238,7 +255,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)) {
@@ -247,13 +264,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;
@@ -264,11 +281,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;
@@ -408,19 +425,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;
@@ -434,23 +451,29 @@ function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
     }
     return { line, column: pos - lastLinePos + generatedDiff };
 }
-function printSourceImpl(sourceFile, originalSourceName, mapGenerator) {
-    const printer = ts.createPrinter({ removeComments: true });
-    const r = printNode(printer, sourceFile.getFullText(), sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
-    return [r, mapGenerator?.toJSON()];
+function printSourceImpl(tsInstance, sourceFile, originalSourceName, mapGenerator) {
+    const ts = tsInstance ?? tsNamespace;
+    const r = printNode(ts, sourceFile.getFullText(), sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
+    // This forces to concatenate strings into flatten one to reduce object trees for ConsString
+    void (r | 0);
+    const json = mapGenerator?.toJSON();
+    if (json) {
+        void (json.mappings | 0);
+    }
+    return [r, json];
 }
-function printNode(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);
+function printNode(tsInstance, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
+    const originalNodeData = node[SYMBOL_ORIGINAL_NODE_DATA];
+    if (originalNodeData) {
+        let result = originalNodeData[1];
+        const comments = tsInstance.getSyntheticTrailingComments(node);
         if (comments) {
             for (const comment of comments) {
                 result += ` /*${comment.text}*/`;
             }
         }
-        const old = originalNode.getText(sourceFile);
-        const oldFull = baseSource.substring(originalNode.pos, originalNode.end);
+        const old = originalNodeData[0];
+        const oldFull = baseSource.substring(originalNodeData[2], originalNodeData[3]);
         const i = oldFull.lastIndexOf(old);
         const leadingUnchanged = i < 0 ? 0 : i;
         const newText = i < 0
@@ -477,7 +500,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) {
@@ -493,7 +516,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, 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.1";
+declare const _default: "0.7.0";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.5.1';
+export default '0.7.0';

package/package.json

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