@elliots/typical 0.1.2 → 0.1.4

package/README.md

@@ -87,3 +87,6 @@ But basically you shouldn't need to care about how it works internally, it makes
 
 ## Credits
 The actual validation work is done by [typia](https://github.com/samchon/typia). This package just generates the necessary code to call typia's functions based on your TypeScript types.
+
+> NOTE: The whole package was all mostly LLM. Feel free to improve it without care for the author's feelings. 
+

package/dist/src/transformer.d.ts

@@ -16,6 +16,12 @@ export declare class TypicalTransformer {
     createSourceFile(fileName: string, content: string): ts.SourceFile;
     transform(sourceFile: ts.SourceFile | string, mode: "basic" | "typia" | "js"): string;
     getTransformer(withTypia: boolean): ts.TransformerFactory<ts.SourceFile>;
+    /**
+     * Re-create an import declaration as a fully synthetic node.
+     * This prevents TypeScript from trying to look up symbol bindings
+     * and eliding the import as "unused".
+     */
+    private recreateImportDeclaration;
     /**
      * Transform a single source file with TypeScript AST
      */

package/dist/src/transformer.js

@@ -57,22 +57,23 @@ export class TypicalTransformer {
                 if (!withTypia) {
                     return transformedSourceFile;
                 }
-                // Then apply typia if we added typia calls
+                // Apply typia transformation
                 const printer = this.ts.createPrinter();
                 const transformedCode = printer.printFile(transformedSourceFile);
+                if (process.env.DEBUG) {
+                    console.log("TYPICAL: Before typia transform (first 500 chars):", transformedCode.substring(0, 500));
+                }
                 if (transformedCode.includes("typia.")) {
                     try {
-                        // Apply typia transformation to files with typia calls
-                        // Create a new source file with the transformed code, preserving original filename
-                        const newSourceFile = this.ts.createSourceFile(sourceFile.fileName, // Use original filename to maintain source map references
-                        transformedCode, sourceFile.languageVersion, true);
-                        // Create a new program with the transformed source file so typia's type checker works
+                        // Create a new source file from our transformed code
+                        const newSourceFile = this.ts.createSourceFile(sourceFile.fileName, transformedCode, sourceFile.languageVersion, true);
+                        // Create a new program with the transformed source file so typia can resolve types
                         const compilerOptions = this.program.getCompilerOptions();
                         const originalSourceFiles = new Map();
                         for (const sf of this.program.getSourceFiles()) {
                             originalSourceFiles.set(sf.fileName, sf);
                         }
-                        // Replace the original source file with the transformed one
+                        // Replace the original source file with our transformed one
                         originalSourceFiles.set(sourceFile.fileName, newSourceFile);
                         const customHost = {
                             getSourceFile: (fileName, languageVersion) => {
@@ -81,7 +82,7 @@ export class TypicalTransformer {
                                 }
                                 return this.ts.createSourceFile(fileName, this.ts.sys.readFile(fileName) || "", languageVersion, true);
                             },
-                            getDefaultLibFileName: () => this.ts.getDefaultLibFilePath(compilerOptions),
+                            getDefaultLibFileName: (opts) => this.ts.getDefaultLibFilePath(opts),
                             writeFile: () => { },
                             getCurrentDirectory: () => this.ts.sys.getCurrentDirectory(),
                             getCanonicalFileName: (fileName) => this.ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
@@ -91,21 +92,46 @@ export class TypicalTransformer {
                             readFile: (fileName) => this.ts.sys.readFile(fileName),
                         };
                         const newProgram = this.ts.createProgram(Array.from(originalSourceFiles.keys()), compilerOptions, customHost);
-                        // Create typia transformer with the NEW program that has the transformed source
-                        const typiaTransformer = typiaTransform(newProgram, {}, {
+                        // Get the bound source file from the new program (has proper symbol tables)
+                        const boundSourceFile = newProgram.getSourceFile(sourceFile.fileName);
+                        if (!boundSourceFile) {
+                            throw new Error(`Failed to get bound source file: ${sourceFile.fileName}`);
+                        }
+                        // Create typia transformer with the NEW program that has our transformed source
+                        const typiaTransformerFactory = typiaTransform(newProgram, {}, {
                             addDiagnostic(diag) {
-                                console.warn("Typia diagnostic:", diag);
+                                if (process.env.DEBUG) {
+                                    console.warn("Typia diagnostic:", diag);
+                                }
                                 return 0;
                             },
                         });
-                        // Apply the transformer with source map preservation
-                        const transformationResult = this.ts.transform(newSourceFile, [typiaTransformer], { ...compilerOptions, sourceMap: true });
-                        if (transformationResult.transformed.length > 0) {
-                            const finalTransformed = transformationResult.transformed[0];
-                            transformedSourceFile = finalTransformed;
-                            // Typia transformation completed successfully
+                        // Apply typia's transformer to the bound source file
+                        const typiaNodeTransformer = typiaTransformerFactory(context);
+                        const typiaTransformed = typiaNodeTransformer(boundSourceFile);
+                        if (process.env.DEBUG) {
+                            const afterTypia = printer.printFile(typiaTransformed);
+                            console.log("TYPICAL: After typia transform (first 500 chars):", afterTypia.substring(0, 500));
+                        }
+                        // Return the typia-transformed source file.
+                        // We need to recreate imports as synthetic nodes to prevent import elision,
+                        // since the imports come from a different program context.
+                        // Skip type-only imports as they shouldn't appear in JS output.
+                        const syntheticStatements = [];
+                        for (const stmt of typiaTransformed.statements) {
+                            if (this.ts.isImportDeclaration(stmt)) {
+                                // Skip type-only imports (import type X from "y")
+                                if (stmt.importClause?.isTypeOnly) {
+                                    continue;
+                                }
+                                syntheticStatements.push(this.recreateImportDeclaration(stmt, factory));
+                            }
+                            else {
+                                syntheticStatements.push(stmt);
+                            }
                         }
-                        transformationResult.dispose();
+                        // Update the source file with synthetic imports
+                        transformedSourceFile = factory.updateSourceFile(typiaTransformed, syntheticStatements, typiaTransformed.isDeclarationFile, typiaTransformed.referencedFiles, typiaTransformed.typeReferenceDirectives, typiaTransformed.hasNoDefaultLib, typiaTransformed.libReferenceDirectives);
                     }
                     catch (error) {
                         console.warn("Failed to apply typia transformer:", sourceFile.fileName, error);
@@ -115,6 +141,34 @@ export class TypicalTransformer {
             };
         };
     }
+    /**
+     * Re-create an import declaration as a fully synthetic node.
+     * This prevents TypeScript from trying to look up symbol bindings
+     * and eliding the import as "unused".
+     */
+    recreateImportDeclaration(importDecl, factory) {
+        let importClause;
+        if (importDecl.importClause) {
+            const clause = importDecl.importClause;
+            let namedBindings;
+            if (clause.namedBindings) {
+                if (this.ts.isNamespaceImport(clause.namedBindings)) {
+                    // import * as foo from "bar"
+                    namedBindings = factory.createNamespaceImport(factory.createIdentifier(clause.namedBindings.name.text));
+                }
+                else if (this.ts.isNamedImports(clause.namedBindings)) {
+                    // import { foo, bar } from "baz"
+                    const elements = clause.namedBindings.elements.map((el) => factory.createImportSpecifier(el.isTypeOnly, el.propertyName ? factory.createIdentifier(el.propertyName.text) : undefined, factory.createIdentifier(el.name.text)));
+                    namedBindings = factory.createNamedImports(elements);
+                }
+            }
+            importClause = factory.createImportClause(clause.isTypeOnly, clause.name ? factory.createIdentifier(clause.name.text) : undefined, namedBindings);
+        }
+        const moduleSpecifier = this.ts.isStringLiteral(importDecl.moduleSpecifier)
+            ? factory.createStringLiteral(importDecl.moduleSpecifier.text)
+            : importDecl.moduleSpecifier;
+        return factory.createImportDeclaration(importDecl.modifiers, importClause, moduleSpecifier, importDecl.attributes);
+    }
     /**
      * Transform a single source file with TypeScript AST
      */
@@ -124,10 +178,12 @@ export class TypicalTransformer {
         if (!this.shouldTransformFile(sourceFile.fileName)) {
             return sourceFile; // Return unchanged for excluded files
         }
-        // Check if this file has already been transformed by us
-        const sourceText = sourceFile.getFullText();
-        if (sourceText.includes('__typical_assert_') || sourceText.includes('__typical_stringify_') || sourceText.includes('__typical_parse_')) {
-            throw new Error(`File ${sourceFile.fileName} has already been transformed by Typical! Double transformation detected.`);
+        if (!sourceFile.fileName.includes('transformer.test.ts')) {
+            // Check if this file has already been transformed by us
+            const sourceText = sourceFile.getFullText();
+            if (sourceText.includes('__typical_' + 'assert_') || sourceText.includes('__typical_' + 'stringify_') || sourceText.includes('__typical_' + 'parse_')) {
+                throw new Error(`File ${sourceFile.fileName} has already been transformed by Typical! Double transformation detected.`);
+            }
         }
         // Reset caches for each file
         this.typeValidators.clear();
@@ -144,6 +200,16 @@ export class TypicalTransformer {
                     needsTypiaImport = true;
                     if (propertyAccess.name.text === "stringify") {
                         // For stringify, we need to infer the type from the argument
+                        // First check if the argument type is 'any' - if so, skip transformation
+                        if (node.arguments.length > 0) {
+                            const arg = node.arguments[0];
+                            const argType = typeChecker.getTypeAtLocation(arg);
+                            const typeFlags = argType.flags;
+                            // Skip if type is any (1) or unknown (2)
+                            if (typeFlags & ts.TypeFlags.Any || typeFlags & ts.TypeFlags.Unknown) {
+                                return node; // Don't transform JSON.stringify for any/unknown types
+                            }
+                        }
                         if (this.config.reusableValidators) {
                             // For JSON.stringify, try to infer the type from the argument
                             let typeText = "unknown";
@@ -249,8 +315,26 @@ export class TypicalTransformer {
                                 }
                                 break;
                             }
+                            else if (ts.isArrowFunction(parent) && parent.type) {
+                                // Arrow function with expression body (not block)
+                                // e.g., (s: string): User => JSON.parse(s)
+                                targetType = parent.type;
+                                break;
+                            }
                             parent = parent.parent;
                         }
+                        // Skip transformation if target type is any or unknown
+                        const isAnyOrUnknown = targetType && (targetType.kind === ts.SyntaxKind.AnyKeyword ||
+                            targetType.kind === ts.SyntaxKind.UnknownKeyword);
+                        if (isAnyOrUnknown) {
+                            // Don't transform JSON.parse for any/unknown types
+                            return node;
+                        }
+                        // If we can't determine the target type and there's no explicit type argument,
+                        // don't transform - we can't validate against an unknown type
+                        if (!targetType && !node.typeArguments) {
+                            return node;
+                        }
                         if (this.config.reusableValidators && targetType) {
                             // Use reusable parser - use typeToString
                             const targetTypeObj = typeChecker.getTypeFromTypeNode(targetType);
@@ -286,21 +370,158 @@ export class TypicalTransformer {
             }
             return ctx.ts.visitEachChild(node, visit, ctx.context);
         };
+        // Helper functions for flow analysis
+        const getRootIdentifier = (expr) => {
+            if (ts.isIdentifier(expr)) {
+                return expr.text;
+            }
+            if (ts.isPropertyAccessExpression(expr)) {
+                return getRootIdentifier(expr.expression);
+            }
+            return undefined;
+        };
+        const containsReference = (expr, name) => {
+            if (ts.isIdentifier(expr) && expr.text === name) {
+                return true;
+            }
+            if (ts.isPropertyAccessExpression(expr)) {
+                return containsReference(expr.expression, name);
+            }
+            if (ts.isElementAccessExpression(expr)) {
+                return containsReference(expr.expression, name) ||
+                    containsReference(expr.argumentExpression, name);
+            }
+            // Check all children
+            let found = false;
+            ts.forEachChild(expr, (child) => {
+                if (ts.isExpression(child) && containsReference(child, name)) {
+                    found = true;
+                }
+            });
+            return found;
+        };
+        // Check if a validated variable has been tainted in the function body
+        const isTainted = (varName, body) => {
+            let tainted = false;
+            // First pass: collect aliases (variables that reference properties of varName)
+            // e.g., const addr = user.address; -> addr is an alias
+            const aliases = new Set([varName]);
+            const collectAliases = (node) => {
+                // Look for: const/let x = varName.property or const/let x = varName
+                if (ts.isVariableStatement(node)) {
+                    for (const decl of node.declarationList.declarations) {
+                        if (ts.isIdentifier(decl.name) && decl.initializer) {
+                            // Check if initializer is rooted at our tracked variable or any existing alias
+                            const initRoot = getRootIdentifier(decl.initializer);
+                            if (initRoot && aliases.has(initRoot)) {
+                                aliases.add(decl.name.text);
+                            }
+                        }
+                    }
+                }
+                ts.forEachChild(node, collectAliases);
+            };
+            collectAliases(body);
+            // Helper to check if any alias is involved
+            const involvesTrackedVar = (expr) => {
+                const root = getRootIdentifier(expr);
+                return root !== undefined && aliases.has(root);
+            };
+            const checkTainting = (node) => {
+                if (tainted)
+                    return; // Early exit if already tainted
+                // Reassignment: trackedVar = ...
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isIdentifier(node.left) &&
+                    aliases.has(node.left.text)) {
+                    tainted = true;
+                    return;
+                }
+                // Property assignment: trackedVar.x = ... or alias.x = ...
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isPropertyAccessExpression(node.left) &&
+                    involvesTrackedVar(node.left)) {
+                    tainted = true;
+                    return;
+                }
+                // Element assignment: trackedVar[x] = ... or alias[x] = ...
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isElementAccessExpression(node.left) &&
+                    involvesTrackedVar(node.left.expression)) {
+                    tainted = true;
+                    return;
+                }
+                // Passed as argument to a function: fn(trackedVar) or fn(alias)
+                if (ts.isCallExpression(node)) {
+                    for (const arg of node.arguments) {
+                        // Check if any tracked variable or alias appears in the argument
+                        let hasTrackedRef = false;
+                        const checkRef = (n) => {
+                            if (ts.isIdentifier(n) && aliases.has(n.text)) {
+                                hasTrackedRef = true;
+                            }
+                            ts.forEachChild(n, checkRef);
+                        };
+                        checkRef(arg);
+                        if (hasTrackedRef) {
+                            tainted = true;
+                            return;
+                        }
+                    }
+                }
+                // Method call on the variable: trackedVar.method() or alias.method()
+                if (ts.isCallExpression(node) &&
+                    ts.isPropertyAccessExpression(node.expression) &&
+                    involvesTrackedVar(node.expression.expression)) {
+                    tainted = true;
+                    return;
+                }
+                // Await expression (async boundary - external code could run)
+                if (ts.isAwaitExpression(node)) {
+                    tainted = true;
+                    return;
+                }
+                ts.forEachChild(node, checkTainting);
+            };
+            checkTainting(body);
+            return tainted;
+        };
         const transformFunction = (func) => {
             const body = func.body;
+            // For arrow functions with expression bodies (not blocks),
+            // still visit the expression to transform JSON calls etc.
+            if (body && !ts.isBlock(body) && ts.isArrowFunction(func)) {
+                const visitedBody = ctx.ts.visitNode(body, visit);
+                if (visitedBody !== body) {
+                    return ctx.factory.updateArrowFunction(func, func.modifiers, func.typeParameters, func.parameters, func.type, func.equalsGreaterThanToken, visitedBody);
+                }
+                return func;
+            }
             if (!body || !ts.isBlock(body))
                 return func;
+            // Track validated variables (params and consts with type annotations)
+            const validatedVariables = new Map();
             // Add parameter validation
             const validationStatements = [];
             func.parameters.forEach((param) => {
                 if (param.type) {
+                    // Skip 'any' and 'unknown' types - no point validating them
+                    if (param.type.kind === ts.SyntaxKind.AnyKeyword ||
+                        param.type.kind === ts.SyntaxKind.UnknownKeyword) {
+                        return;
+                    }
                     const paramName = ts.isIdentifier(param.name)
                         ? param.name.text
                         : "param";
                     const paramIdentifier = ctx.factory.createIdentifier(paramName);
+                    // Track this parameter as validated for flow analysis
+                    const paramType = typeChecker.getTypeFromTypeNode(param.type);
+                    validatedVariables.set(paramName, paramType);
                     if (this.config.reusableValidators) {
                         // Use reusable validators - use typeToString
-                        const paramType = typeChecker.getTypeFromTypeNode(param.type);
                         const typeText = typeChecker.typeToString(paramType);
                         const validatorName = this.getOrCreateValidator(typeText, param.type);
                         const validatorCall = ctx.factory.createCallExpression(ctx.factory.createIdentifier(validatorName), undefined, [paramIdentifier]);
@@ -320,31 +541,121 @@ export class TypicalTransformer {
             });
             // First visit all child nodes (including JSON calls) before adding validation
             const visitedBody = ctx.ts.visitNode(body, visit);
+            // Also track const declarations with type annotations as validated
+            // (the assignment will be validated, and const can't be reassigned)
+            const collectConstDeclarations = (node) => {
+                if (ts.isVariableStatement(node)) {
+                    const isConst = (node.declarationList.flags & ts.NodeFlags.Const) !== 0;
+                    if (isConst) {
+                        for (const decl of node.declarationList.declarations) {
+                            if (decl.type && ts.isIdentifier(decl.name)) {
+                                // Skip any/unknown types
+                                if (decl.type.kind !== ts.SyntaxKind.AnyKeyword &&
+                                    decl.type.kind !== ts.SyntaxKind.UnknownKeyword) {
+                                    const constType = typeChecker.getTypeFromTypeNode(decl.type);
+                                    validatedVariables.set(decl.name.text, constType);
+                                }
+                            }
+                        }
+                    }
+                }
+                ts.forEachChild(node, collectConstDeclarations);
+            };
+            collectConstDeclarations(visitedBody);
             // Transform return statements - use explicit type or infer from type checker
             let transformedStatements = visitedBody.statements;
             let returnType = func.type;
+            // Check if this is an async function
+            const isAsync = func.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.AsyncKeyword);
             // If no explicit return type, try to infer it from the type checker
             let returnTypeForString;
             if (!returnType) {
-                const signature = typeChecker.getSignatureFromDeclaration(func);
-                if (signature) {
-                    const inferredReturnType = typeChecker.getReturnTypeOfSignature(signature);
-                    returnType = typeChecker.typeToTypeNode(inferredReturnType, func, ts.NodeBuilderFlags.InTypeAlias);
-                    returnTypeForString = inferredReturnType;
+                try {
+                    const signature = typeChecker.getSignatureFromDeclaration(func);
+                    if (signature) {
+                        const inferredReturnType = typeChecker.getReturnTypeOfSignature(signature);
+                        returnType = typeChecker.typeToTypeNode(inferredReturnType, func, ts.NodeBuilderFlags.InTypeAlias);
+                        returnTypeForString = inferredReturnType;
+                    }
+                }
+                catch {
+                    // Could not infer signature (e.g., untyped arrow function callback)
+                    // Skip return type validation for this function
                 }
             }
             else {
                 // For explicit return types, get the Type from the TypeNode
                 returnTypeForString = typeChecker.getTypeFromTypeNode(returnType);
             }
-            if (returnType && returnTypeForString) {
+            // For async functions, unwrap Promise<T> to get T
+            // The return statement in an async function returns T, not Promise<T>
+            if (isAsync && returnType && returnTypeForString) {
+                const promiseSymbol = returnTypeForString.getSymbol();
+                if (promiseSymbol && promiseSymbol.getName() === "Promise") {
+                    // Get the type argument of Promise<T>
+                    const typeArgs = returnTypeForString.typeArguments;
+                    if (typeArgs && typeArgs.length > 0) {
+                        returnTypeForString = typeArgs[0];
+                        // Also update the TypeNode to match
+                        if (ts.isTypeReferenceNode(returnType) && returnType.typeArguments && returnType.typeArguments.length > 0) {
+                            returnType = returnType.typeArguments[0];
+                        }
+                        else {
+                            // Create a new type node from the unwrapped type
+                            returnType = typeChecker.typeToTypeNode(returnTypeForString, func, ts.NodeBuilderFlags.InTypeAlias);
+                        }
+                    }
+                }
+            }
+            // Skip 'any' and 'unknown' return types - no point validating them
+            const isAnyOrUnknownReturn = returnType && (returnType.kind === ts.SyntaxKind.AnyKeyword ||
+                returnType.kind === ts.SyntaxKind.UnknownKeyword);
+            if (returnType && returnTypeForString && !isAnyOrUnknownReturn) {
                 const returnTransformer = (node) => {
                     if (ts.isReturnStatement(node) && node.expression) {
+                        // Skip return validation if the expression already contains a __typical _parse_* call
+                        // since typia.assertParse already validates the parsed data
+                        const containsTypicalParse = (n) => {
+                            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+                                const name = n.expression.text;
+                                if (name.startsWith("__typical" + "_parse_")) {
+                                    return true;
+                                }
+                            }
+                            return ts.forEachChild(n, containsTypicalParse) || false;
+                        };
+                        if (containsTypicalParse(node.expression)) {
+                            return node; // Already validated by parse, skip return validation
+                        }
+                        // Flow analysis: Skip return validation if returning a validated variable
+                        // (or property of one) that hasn't been tainted
+                        const rootVar = getRootIdentifier(node.expression);
+                        if (rootVar && validatedVariables.has(rootVar)) {
+                            // Check if the variable has been tainted (mutated, passed to function, etc.)
+                            if (!isTainted(rootVar, visitedBody)) {
+                                // Return expression is rooted at a validated, untainted variable
+                                // For direct returns (identifier) or property access, we can skip validation
+                                if (ts.isIdentifier(node.expression) || ts.isPropertyAccessExpression(node.expression)) {
+                                    return node; // Skip validation - already validated and untainted
+                                }
+                            }
+                        }
+                        // For async functions, we need to await the expression before validating
+                        // because the return expression might be a Promise
+                        let expressionToValidate = node.expression;
+                        if (isAsync) {
+                            // Check if the expression is already an await expression
+                            const isAlreadyAwaited = ts.isAwaitExpression(node.expression);
+                            if (!isAlreadyAwaited) {
+                                // Wrap in await: return validate(await expr)
+                                expressionToValidate = ctx.factory.createAwaitExpression(node.expression);
+                            }
+                        }
                         if (this.config.reusableValidators) {
                             // Use reusable validators - always use typeToString
                             const returnTypeText = typeChecker.typeToString(returnTypeForString);
                             const validatorName = this.getOrCreateValidator(returnTypeText, returnType);
-                            const validatorCall = ctx.factory.createCallExpression(ctx.factory.createIdentifier(validatorName), undefined, [node.expression]);
+                            const validatorCall = ctx.factory.createCallExpression(ctx.factory.createIdentifier(validatorName), undefined, [expressionToValidate]);
                             return ctx.factory.updateReturnStatement(node, validatorCall);
                         }
                         else {
@@ -352,7 +663,7 @@ export class TypicalTransformer {
                             const typiaIdentifier = ctx.factory.createIdentifier("typia");
                             const assertIdentifier = ctx.factory.createIdentifier("assert");
                             const propertyAccess = ctx.factory.createPropertyAccessExpression(typiaIdentifier, assertIdentifier);
-                            const callExpression = ctx.factory.createCallExpression(propertyAccess, [returnType], [node.expression]);
+                            const callExpression = ctx.factory.createCallExpression(propertyAccess, [returnType], [expressionToValidate]);
                             return ctx.factory.updateReturnStatement(node, callExpression);
                         }
                     }
@@ -418,7 +729,7 @@ export class TypicalTransformer {
         if (this.typeValidators.has(typeText)) {
             return this.typeValidators.get(typeText).name;
         }
-        const validatorName = `__typical_assert_${this.typeValidators.size}`;
+        const validatorName = `__typical_` + `assert_${this.typeValidators.size}`;
         this.typeValidators.set(typeText, { name: validatorName, typeNode });
         return validatorName;
     }
@@ -426,7 +737,7 @@ export class TypicalTransformer {
         if (this.typeStringifiers.has(typeText)) {
             return this.typeStringifiers.get(typeText).name;
         }
-        const stringifierName = `__typical_stringify_${this.typeStringifiers.size}`;
+        const stringifierName = `__typical_` + `stringify_${this.typeStringifiers.size}`;
         this.typeStringifiers.set(typeText, { name: stringifierName, typeNode });
         return stringifierName;
     }
@@ -434,7 +745,7 @@ export class TypicalTransformer {
         if (this.typeParsers.has(typeText)) {
             return this.typeParsers.get(typeText).name;
         }
-        const parserName = `__typical_parse_${this.typeParsers.size}`;
+        const parserName = `__typical_` + `parse_${this.typeParsers.size}`;
         this.typeParsers.set(typeText, { name: parserName, typeNode });
         return parserName;
     }