ts-const-value-transformer 0.9.0 → 0.10.0

package/dist/transform.mjs

@@ -1,10 +1,8 @@
 import * as sourceMap from 'source-map';
-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 ?? tsNamespace,
         hoistProperty: options.hoistProperty ?? true,
         hoistEnumValues: options.hoistEnumValues ?? true,
         hoistExternalValues: options.hoistExternalValues ?? true,
@@ -14,6 +12,7 @@ function assignDefaultValues(options = {}) {
         unsafeHoistWritableValues: options.unsafeHoistWritableValues ?? false,
         useUndefinedSymbolForUndefinedValue: options.useUndefinedSymbolForUndefinedValue ?? false,
         hoistUndefinedSymbol: options.hoistUndefinedSymbol ?? true,
+        hoistConstTemplateLiteral: options.hoistConstTemplateLiteral ?? false,
         externalNames: options.externalNames ?? [],
         ignoreFiles: options.ignoreFiles ?? [],
     };
@@ -39,27 +38,29 @@ export function getIgnoreFilesFunction(ignoreFiles) {
     };
 }
 ////////////////////////////////////////////////////////////////////////////////
-export function transformSource(sourceFile, program, context, options) {
+export function transformSourceWithProxy(sourceFile, proxy, context, options) {
     const requiredOptions = assignDefaultValues(options);
-    const ts = requiredOptions.ts;
-    return ts.visitEachChild(sourceFile, (node) => visitNodeChildren(node, sourceFile, sourceFile, program, requiredOptions, context, (node) => {
+    return transformSourceWithProxyImpl(sourceFile, proxy, context, requiredOptions);
+}
+// @internal
+export function transformSourceWithProxyImpl(sourceFile, proxy, context, requiredOptions) {
+    return proxy.visitEachChild(sourceFile, (node) => visitNodeChildren(node, sourceFile, sourceFile, proxy, requiredOptions, context, (node) => {
         // skip statements which would not have 'value' expressions
-        if (ts.isInterfaceDeclaration(node) ||
-            ts.isTypeAliasDeclaration(node) ||
+        if (proxy.isInterfaceDeclaration(node) ||
+            proxy.isTypeAliasDeclaration(node) ||
             // Identifies in import clause should not be parsed
-            ts.isImportDeclaration(node) ||
-            ts.isTypeOnlyExportDeclaration(node)) {
+            proxy.isImportDeclaration(node) ||
+            proxy.isTypeOnlyExportDeclaration(node)) {
             return false;
         }
         return true;
     }), context);
 }
-function visitNodeChildren(node, parent, sourceFile, program, options, context, fnVisit, visitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace) {
-    const ts = options.ts;
+function visitNodeChildren(node, parent, sourceFile, proxy, options, context, fnVisit, visitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace) {
     if (fnVisitBeforeReplace) {
         fnVisitBeforeReplace(node, parent, visitContext);
     }
-    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context, visitContext, fnReplace ?? 'create');
+    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, proxy, options, context, visitContext, fnReplace ?? 'create');
     if (newNode == null) {
         return node;
     }
@@ -72,136 +73,136 @@ function visitNodeChildren(node, parent, sourceFile, program, options, context,
     const childVisitContext = fnVisitBeforeChild
         ? fnVisitBeforeChild(node, parent, visitContext)
         : visitContext;
-    const r = ts.visitEachChild(node, (nodeChild) => visitNodeChildren(nodeChild, node, sourceFile, program, options, context, fnVisit, childVisitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace), context);
+    const r = proxy.visitEachChild(node, (nodeChild) => visitNodeChildren(nodeChild, node, sourceFile, proxy, options, context, fnVisit, childVisitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace), context);
     if (fnVisitAfterChild) {
         fnVisitAfterChild(node, parent, childVisitContext);
     }
     return r;
 }
-function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context, visitContext, replaceOption) {
-    const ts = options.ts;
-    if (ts.isCallLikeExpression(node)) {
-        if (!ts.isExpression(node) ||
+function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, proxy, options, context, visitContext, replaceOption) {
+    if (proxy.isCallLikeExpression(node)) {
+        if (!proxy.isExpression(node) ||
             (!options.unsafeHoistFunctionCall &&
                 (!options.hoistPureFunctionCall ||
-                    !hasPureAnnotation(node, sourceFile, ts)))) {
+                    !proxy.hasPureAnnotation(node, sourceFile)))) {
             return node;
         }
     }
-    else if (ts.isIdentifier(node)) {
-        if (!ts.isComputedPropertyName(parent) &&
-            ((!ts.isExpression(parent) &&
+    else if (proxy.isIdentifier(node)) {
+        if (!proxy.isComputedPropertyName(parent) &&
+            ((!proxy.isExpression(parent) &&
                 (!('initializer' in parent) || node !== parent.initializer)) ||
-                (ts.isPropertyAccessExpression(parent) && node === parent.name))) {
+                (proxy.isPropertyAccessExpression(parent) && node === parent.name))) {
             return node;
         }
-        if (!options.hoistEnumValues && isEnumIdentifier(node, program, ts)) {
+        if (!options.hoistEnumValues && proxy.isEnumIdentifier(node, sourceFile)) {
             return node;
         }
         if (!options.hoistUndefinedSymbol &&
-            isUndefinedIdentifier(node, parent, program, ts)) {
+            proxy.isUndefinedIdentifier(node, parent, sourceFile)) {
             return node;
         }
     }
-    else if (ts.isPropertyAccessExpression(node) ||
-        ts.isElementAccessExpression(node)) {
-        if (!isHoistablePropertyAccess(node, program, ts)) {
+    else if (proxy.isPropertyAccessExpression(node) ||
+        proxy.isElementAccessExpression(node)) {
+        if (!proxy.isHoistablePropertyAccess(node, sourceFile)) {
             return node;
         }
-        if ((!options.hoistProperty && !isEnumAccess(node, program, ts)) ||
+        if ((!options.hoistProperty && !proxy.isEnumAccess(node, sourceFile)) ||
             (!options.hoistEnumValues &&
-                (isEnumAccess(node, program, ts) ||
-                    (ts.isIdentifier(node) && isEnumIdentifier(node, program, ts))))) {
+                (proxy.isEnumAccess(node, sourceFile) ||
+                    (proxy.isIdentifier(node) &&
+                        proxy.isEnumIdentifier(node, sourceFile))))) {
             return node;
         }
     }
-    else if (ts.isAsExpression(node)) {
+    else if (proxy.isAsExpression(node)) {
         if (!options.unsafeHoistAsExpresion) {
             return node;
         }
     }
+    else if (proxy.isTemplateExpression(node)) {
+        if (!options.hoistConstTemplateLiteral) {
+            return node;
+        }
+    }
     else {
         return node;
     }
     if (!options.hoistExternalValues &&
-        isExternalReference(node, program, options.externalNames, ts)) {
+        proxy.isExternalReference(node, options.externalNames, sourceFile)) {
         return node;
     }
-    if (!options.unsafeHoistAsExpresion && hasAsExpression(node, ts, context)) {
+    if (!options.unsafeHoistAsExpresion &&
+        hasAsExpression(node, proxy, context)) {
         return node;
     }
     if (!options.unsafeHoistWritableValues) {
-        const r = isReadonlyExpression(node, program, ts);
+        const r = proxy.isReadonlyExpression(node, sourceFile);
         if (r === false) {
             return node;
         }
     }
     try {
-        const typeChecker = program.getTypeChecker();
-        const type = typeChecker.getTypeAtLocation(node);
-        const flags = type.getFlags();
+        const type = proxy.getTypeAtLocation(node, sourceFile);
         let newNode;
-        if (type.isUnionOrIntersection()) {
+        if (!type) {
             return node;
         }
         let newSource;
-        if (type.isStringLiteral()) {
-            if (replaceOption === 'create') {
-                newNode = ts.factory.createStringLiteral(type.value);
+        if (proxy.isStringLiteral(type)) {
+            if (replaceOption === 'create' && proxy.factory) {
+                newNode = proxy.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()) {
+            newSource = proxy.makeStringLiteralSource(type.value);
+        }
+        else if (proxy.isNumberLiteral(type)) {
             if (type.value < 0) {
-                if (replaceOption === 'create') {
-                    newNode = ts.factory.createParenthesizedExpression(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-type.value)));
+                if (replaceOption === 'create' && proxy.factory) {
+                    newNode = proxy.factory.createParenthesizedExpression(proxy.factory.createExpressionWithMinusToken(proxy.factory.createNumericLiteral(-type.value)));
                 }
                 newSource = `(-${-type.value})`;
             }
             else {
-                if (replaceOption === 'create') {
-                    newNode = ts.factory.createNumericLiteral(type.value);
+                if (replaceOption === 'create' && proxy.factory) {
+                    newNode = proxy.factory.createNumericLiteral(type.value);
                 }
                 newSource = `${type.value}`;
             }
         }
-        else if (flags & ts.TypeFlags.BigIntLiteral) {
-            const text = typeChecker.typeToString(type);
-            if (replaceOption === 'create') {
-                newNode = ts.factory.createBigIntLiteral(text);
+        else if (proxy.isBigIntLiteral(type)) {
+            const text = proxy.typeToString(type);
+            if (replaceOption === 'create' && proxy.factory) {
+                newNode = proxy.factory.createBigIntLiteral(text);
             }
             newSource = text;
         }
-        else if (flags & ts.TypeFlags.BooleanLiteral) {
-            const text = typeChecker.typeToString(type);
-            if (replaceOption === 'create') {
+        else if (proxy.isBooleanLiteral(type)) {
+            const text = proxy.typeToString(type);
+            if (replaceOption === 'create' && proxy.factory) {
                 newNode =
-                    text === 'true' ? ts.factory.createTrue() : ts.factory.createFalse();
+                    text === 'true'
+                        ? proxy.factory.createTrue()
+                        : proxy.factory.createFalse();
             }
             newSource = text;
         }
-        else if (flags & ts.TypeFlags.Null) {
-            if (replaceOption === 'create') {
-                newNode = ts.factory.createNull();
+        else if (proxy.isNullType(type)) {
+            if (replaceOption === 'create' && proxy.factory) {
+                newNode = proxy.factory.createNull();
             }
             newSource = 'null';
         }
-        else if (flags & ts.TypeFlags.Undefined) {
+        else if (proxy.isUndefinedType(type)) {
             if (options.useUndefinedSymbolForUndefinedValue) {
-                if (replaceOption === 'create') {
-                    newNode = ts.factory.createIdentifier('undefined');
+                if (replaceOption === 'create' && proxy.factory) {
+                    newNode = proxy.factory.createIdentifier('undefined');
                 }
                 newSource = 'undefined';
             }
             else {
-                if (replaceOption === 'create') {
-                    newNode = ts.factory.createParenthesizedExpression(ts.factory.createVoidZero());
+                if (replaceOption === 'create' && proxy.factory) {
+                    newNode = proxy.factory.createParenthesizedExpression(proxy.factory.createVoidZero());
                 }
                 newSource = '(void 0)';
             }
@@ -209,20 +210,20 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
         else {
             return node;
         }
-        const originalSource = node.getText(sourceFile);
+        const originalSource = proxy.getNodeText(node, sourceFile);
         const comment = ` ${originalSource.replace(/\/\*/g, ' *').replace(/\*\//g, '* ')} `;
         let result = newNode
-            ? ts.addSyntheticTrailingComment(newNode, ts.SyntaxKind.MultiLineCommentTrivia, comment)
+            ? proxy.appendMultiLineComment(newNode, comment)
             : undefined;
         newSource = `${newSource} /*${comment}*/`;
         if (/[\r\n]/m.test(originalSource)) {
-            if (result) {
-                result = ts.factory.createParenthesizedExpression(result);
+            if (result && proxy.factory) {
+                result = proxy.factory.createParenthesizedExpression(result);
             }
             newSource = `(${newSource})`;
         }
         if (result) {
-            ts.setTextRange(result, node);
+            proxy.setTextRange(result, node);
             result[SYMBOL_ORIGINAL_NODE_DATA] = [
                 originalSource,
                 newSource,
@@ -239,226 +240,33 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
         return node;
     }
 }
-function isEnumAccess(node, program, tsInstance) {
-    const ts = tsInstance;
-    const typeChecker = program.getTypeChecker();
-    const type = typeChecker.getTypeAtLocation(node);
-    return (type.getFlags() & ts.TypeFlags.EnumLiteral) !== 0;
-}
-function isEnumIdentifier(node, program, tsInstance) {
-    const ts = tsInstance;
-    const typeChecker = program.getTypeChecker();
-    const type = typeChecker.getTypeAtLocation(node);
-    return (type.getFlags() & ts.TypeFlags.EnumLiteral) !== 0;
-}
-function isExternalReference(node, program, externalNames, tsInstance) {
-    const ts = tsInstance;
-    const typeChecker = program.getTypeChecker();
-    const nodeSym = typeChecker.getSymbolAtLocation(node);
-    let nodeFrom = nodeSym?.getDeclarations()?.[0];
-    while (nodeFrom) {
-        const sourceFileName = nodeFrom.getSourceFile();
-        if (externalNames.length === 0) {
-            if (/[\\/]node_modules[\\/]/.test(sourceFileName.fileName)) {
-                return true;
-            }
-        }
-        else {
-            if (externalNames.some((part) => {
-                if (typeof part === 'string') {
-                    return sourceFileName.fileName.replace(/\\/g, '/').includes(part);
-                }
-                else {
-                    return part.test(sourceFileName.fileName);
-                }
-            })) {
-                return true;
-            }
-        }
-        // Walk into the 'import' variables
-        if (!ts.isImportSpecifier(nodeFrom)) {
-            break;
-        }
-        const baseName = nodeFrom.propertyName ?? nodeFrom.name;
-        const baseSym = typeChecker.getSymbolAtLocation(baseName);
-        // We must follow 'aliased' symbol for parsing the symbol which name is not changed from the exported symbol name
-        const exportedSym = baseSym && baseSym.getFlags() & ts.SymbolFlags.Alias
-            ? typeChecker.getAliasedSymbol(baseSym)
-            : baseSym;
-        nodeFrom = exportedSym?.getDeclarations()?.[0];
-    }
-    const type = typeChecker.getTypeAtLocation(node);
-    const sym = type.getSymbol();
-    if (!sym) {
-        return false;
-    }
-    const def = sym.getDeclarations()?.[0];
-    if (!def) {
-        return false;
-    }
-    const typeDefinitionSource = def.getSourceFile();
-    if (program.isSourceFileFromExternalLibrary(typeDefinitionSource)) {
-        return true;
-    }
-    return false;
-}
-function hasAsExpression(node, tsInstance, context) {
-    const ts = tsInstance;
+function hasAsExpression(node, proxy, context) {
     // including 'as const'
-    if (ts.isAsExpression(node)) {
+    if (proxy.isAsExpression(node)) {
         return true;
     }
     let found = false;
-    ts.visitEachChild(node, (node) => {
+    proxy.visitEachChild(node, (node) => {
         if (!found) {
-            found = hasAsExpression(node, ts, context);
+            found = hasAsExpression(node, proxy, context);
         }
         return node;
     }, context);
     return found;
 }
-function hasPureAnnotation(node, sourceFile, tsInstance) {
-    const ts = tsInstance;
-    const fullText = node.getFullText(sourceFile);
-    const ranges = ts.getLeadingCommentRanges(fullText, 0) ?? [];
-    for (const range of ranges) {
-        if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
-            continue;
-        }
-        const text = fullText.slice(range.pos + 2, range.end - 2).trim();
-        if ((text[0] === '@' || text[0] === '#') && text.slice(1) === '__PURE__') {
-            return true;
-        }
-    }
-    return false;
-}
-function getNameFromElementAccessExpression(node, typeChecker) {
-    const type = typeChecker.getTypeAtLocation(node.argumentExpression);
-    if (type.isStringLiteral() || type.isNumberLiteral()) {
-        return `${type.value}`;
-    }
-    return null;
-}
-function isReadonlyPropertyAccess(a, typeChecker, tsInstance) {
-    const ts = tsInstance;
-    const type = typeChecker.getTypeAtLocation(a.expression);
-    const memberName = ts.isPropertyAccessExpression(a)
-        ? a.name.getText()
-        : getNameFromElementAccessExpression(a, typeChecker);
-    if (memberName == null) {
-        return false;
-    }
-    if (type.getFlags() & ts.TypeFlags.Object) {
-        const prop = type.getProperty(memberName);
-        if (prop) {
-            // Use internal but exported function to improve memory performance
-            if ('getCheckFlags' in ts &&
-                'CheckFlags' in ts &&
-                ts.CheckFlags.Readonly != null) {
-                const checkFlags = ts.getCheckFlags(prop);
-                if (checkFlags & ts.CheckFlags.Readonly) {
-                    return true;
-                }
-            }
-            if ('getDeclarationModifierFlagsFromSymbol' in ts) {
-                const modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(prop);
-                if (modifierFlags & ts.ModifierFlags.Readonly) {
-                    return true;
-                }
-            }
-            if (prop.declarations && prop.declarations.length > 0) {
-                const decl = prop.declarations[0];
-                if (ts.isPropertySignature(decl) &&
-                    decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword)) {
-                    return true;
-                }
-                if (ts.isVariableDeclaration(decl) &&
-                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-                    decl.parent &&
-                    ts.isVariableDeclarationList(decl.parent) &&
-                    decl.parent.flags & ts.NodeFlags.Const) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-function isReadonlyExpression(node, program, tsInstance) {
-    const ts = tsInstance;
-    const typeChecker = program.getTypeChecker();
-    if (ts.isIdentifier(node) &&
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        node.parent &&
-        !ts.isPropertyAccessExpression(node.parent)) {
-        const nodeSym = typeChecker.getSymbolAtLocation(node);
-        if (nodeSym?.valueDeclaration) {
-            if (ts.isVariableDeclarationList(nodeSym.valueDeclaration.parent)) {
-                if (nodeSym.valueDeclaration.parent.flags & ts.NodeFlags.Const) {
-                    return true;
-                }
-                return false;
-            }
-        }
-    }
-    if (ts.isPropertyAccessExpression(node) ||
-        ts.isElementAccessExpression(node)) {
-        if (isEnumAccess(node, program, ts)) {
-            return true;
-        }
-        return isReadonlyPropertyAccess(node, typeChecker, ts);
-    }
-    return null;
-}
-function isHoistablePropertyAccess(a, program, tsInstance) {
-    const ts = tsInstance;
-    const typeChecker = program.getTypeChecker();
-    const type = typeChecker.getTypeAtLocation(a.expression);
-    const memberName = ts.isPropertyAccessExpression(a)
-        ? a.name.getText()
-        : getNameFromElementAccessExpression(a, typeChecker);
-    if (memberName == null) {
-        return false;
-    }
-    if (type.getFlags() & ts.TypeFlags.Object) {
-        const prop = type.getProperty(memberName);
-        // If the property access uses indexed access, `prop` will be undefined
-        if (prop) {
-            return true;
-        }
-    }
-    return false;
-}
-function isUndefinedIdentifier(node, parent, program, tsInstance) {
-    if (tsInstance.isPropertyAccessExpression(parent) ||
-        tsInstance.isElementAccessExpression(parent)) {
-        return false;
-    }
-    const typeChecker = program.getTypeChecker();
-    const type = typeChecker.getTypeAtLocation(node);
-    const sym = typeChecker.getSymbolAtLocation(node);
-    if (!sym || sym.getEscapedName().toString() !== 'undefined') {
-        return false;
-    }
-    if (type.isUnionOrIntersection() ||
-        !(type.getFlags() & tsInstance.TypeFlags.Undefined)) {
-        return false;
-    }
-    return true;
-}
 ////////////////////////////////////////////////////////////////////////////////
-export function printSource(sourceFile, tsInstance) {
-    return printSourceImpl(tsInstance, sourceFile)[0];
+export function printSourceWithProxy(sourceFile, proxy) {
+    return printSourceImpl(proxy, sourceFile)[0];
 }
-export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap, tsInstance) {
+export function printSourceWithMapWithProxy(sourceFile, originalSourceName, proxy, startOfSourceMap) {
     const generator = new sourceMap.SourceMapGenerator(startOfSourceMap);
-    generator.setSourceContent(originalSourceName, sourceFile.getFullText());
-    return printSourceImpl(tsInstance, sourceFile, originalSourceName, generator);
+    generator.setSourceContent(originalSourceName, sourceFile.text);
+    return printSourceImpl(proxy, sourceFile, originalSourceName, generator);
 }
-function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
+function positionToLineAndColumn(proxy, sourceFile, pos, generatedDiff) {
     let line = 0;
     let lastLinePos = 0;
-    for (const linePos of sourceFile.getLineStarts()) {
+    for (const linePos of proxy.getLineStarts(sourceFile)) {
         if (pos < linePos) {
             break;
         }
@@ -467,12 +275,11 @@ function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
     }
     return { line, column: pos - lastLinePos + generatedDiff };
 }
-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);
+function printSourceImpl(proxy, sourceFile, originalSourceName, mapGenerator) {
+    const r = printNode(proxy, sourceFile.text, sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
     return [r, mapGenerator?.toJSON()];
 }
-function printNode(tsInstance, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
+function printNode(proxy, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
     const originalNodeData = node[SYMBOL_ORIGINAL_NODE_DATA];
     if (originalNodeData) {
         const result = originalNodeData[1];
@@ -494,7 +301,7 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
     let output = '';
     let headPrinted = false;
     let lastChildPos = 0;
-    tsInstance.visitEachChild(node, (child) => {
+    proxy.visitEachChild(node, (child) => {
         if (!headPrinted) {
             headPrinted = true;
             if (child.pos > node.pos) {
@@ -508,7 +315,7 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
             output += text;
             posContext.pos = child.pos;
         }
-        output += printNode(tsInstance, baseSource, sourceFile, child, posContext, originalSourceName, mapGenerator);
+        output += printNode(proxy, baseSource, sourceFile, child, posContext, originalSourceName, mapGenerator);
         lastChildPos = child.end;
         return child;
     }, void 0);
@@ -523,7 +330,7 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
     }
     return output;
     function addMappingForCurrent(name) {
-        const original = positionToLineAndColumn(sourceFile, posContext.pos, 0);
+        const original = positionToLineAndColumn(proxy, sourceFile, posContext.pos, 0);
         if (original.line !== posContext.lastLine) {
             posContext.diff = 0;
             posContext.lastLine = original.line;
@@ -531,7 +338,7 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
         if (mapGenerator) {
             mapGenerator.addMapping({
                 original,
-                generated: positionToLineAndColumn(sourceFile, posContext.pos, posContext.diff),
+                generated: positionToLineAndColumn(proxy, sourceFile, posContext.pos, posContext.diff),
                 source: originalSourceName,
                 name,
             });
@@ -539,24 +346,24 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
     }
 }
 ////////////////////////////////////////////////////////////////////////////////
-export function transformAndPrintSource(sourceFile, program, context, options) {
-    return transformAndPrintSourceImpl(sourceFile, program, context, options)[0];
+export function transformAndPrintSourceWithProxy(sourceFile, proxy, context, options) {
+    return transformAndPrintSourceImpl(sourceFile, proxy, context, options)[0];
 }
-export function transformAndPrintSourceWithMap(sourceFile, program, context, originalSourceName, options, startOfSourceMap) {
+export function transformAndPrintSourceWithMapWithProxy(sourceFile, proxy, context, originalSourceName, options, startOfSourceMap) {
     const generator = new sourceMap.SourceMapGenerator(startOfSourceMap);
-    return transformAndPrintSourceImpl(sourceFile, program, context, options, originalSourceName, generator);
+    return transformAndPrintSourceImpl(sourceFile, proxy, context, options, originalSourceName, generator);
 }
-function transformAndPrintSourceImpl(sourceFile, program, context, options, originalSourceName, mapGenerator) {
+function transformAndPrintSourceImpl(sourceFile, proxy, context, options, originalSourceName, mapGenerator) {
     const requiredOptions = assignDefaultValues(options);
     if (mapGenerator) {
-        mapGenerator.setSourceContent(originalSourceName, sourceFile.getFullText());
+        mapGenerator.setSourceContent(originalSourceName, sourceFile.text);
     }
-    const r = transformAndPrintNode({ pos: 0, diff: 0, lastLine: 0 }, sourceFile.getFullText(), sourceFile, program, context, requiredOptions, originalSourceName, mapGenerator);
+    const r = transformAndPrintNode({ pos: 0, diff: 0, lastLine: 0 }, sourceFile.text, sourceFile, proxy, context, requiredOptions, originalSourceName, mapGenerator);
     return [r, mapGenerator?.toJSON()];
 }
-function transformAndPrintNode(posContext, baseSource, sourceFile, program, context, options, originalSourceName, mapGenerator) {
+function transformAndPrintNode(posContext, baseSource, sourceFile, proxy, context, options, originalSourceName, mapGenerator) {
     let output = '';
-    visitNodeChildren(sourceFile, sourceFile, sourceFile, program, options, context, 
+    visitNodeChildren(sourceFile, sourceFile, sourceFile, proxy, options, context, 
     // fnVisit
     (child, _parent, visitContext) => {
         visitContext.lastChildPos = child.end;
@@ -623,7 +430,7 @@ function transformAndPrintNode(posContext, baseSource, sourceFile, program, cont
     });
     return output;
     function addMappingForCurrent(name) {
-        const original = positionToLineAndColumn(sourceFile, posContext.pos, 0);
+        const original = positionToLineAndColumn(proxy, sourceFile, posContext.pos, 0);
         if (original.line !== posContext.lastLine) {
             posContext.diff = 0;
             posContext.lastLine = original.line;
@@ -631,7 +438,7 @@ function transformAndPrintNode(posContext, baseSource, sourceFile, program, cont
         if (mapGenerator) {
             mapGenerator.addMapping({
                 original,
-                generated: positionToLineAndColumn(sourceFile, posContext.pos, posContext.diff),
+                generated: positionToLineAndColumn(proxy, sourceFile, posContext.pos, posContext.diff),
                 source: originalSourceName,
                 name,
             });

package/dist/tscTransformer.d.mts

@@ -0,0 +1,8 @@
+import type * as sourceMap from 'source-map';
+import type * as ts from 'typescript';
+import { type TransformOptions } from './transform.mjs';
+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];
+export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions): ts.SourceFile;
+export declare function transformAndPrintSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions): string;
+export declare function transformAndPrintSourceWithMap(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, originalSourceName: string, options?: TransformOptions, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];