ts-jest 26.3.0 → 26.4.2

package/dist/config/paths-to-module-name-mapper.d.ts

@@ -1,6 +1,6 @@
 import type { Config } from '@jest/types';
 declare type JestPathMapping = Config.InitialOptions['moduleNameMapper'];
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
+    prefix: string;
 }) => JestPathMapping;
 export {};

package/dist/config/paths-to-module-name-mapper.js

@@ -14,41 +14,42 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pathsToModuleNameMapper = void 0;
 var bs_logger_1 = require("bs-logger");
-var logger_1 = require("../util/logger");
-var messages_1 = require("../util/messages");
-// we don't need to escape all chars, so commented out is the real one
-// const escapeRegex = (str: string) => str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
+var logger_1 = require("../utils/logger");
+var messages_1 = require("../utils/messages");
 var escapeRegex = function (str) { return str.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&'); };
 var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'path-mapper', _a));
 exports.pathsToModuleNameMapper = function (mapping, _a) {
     var e_1, _b;
-    var _c = (_a === void 0 ? {} : _a).prefix, prefix = _c === void 0 ? '' : _c;
+    var _c = (_a === void 0 ? Object.create(null) : _a).prefix, prefix = _c === void 0 ? '' : _c;
     var jestMap = {};
     try {
         for (var _d = __values(Object.keys(mapping)), _e = _d.next(); !_e.done; _e = _d.next()) {
             var fromPath = _e.value;
             var pattern = void 0;
             var toPaths = mapping[fromPath];
-            // check that we have only one target path
             if (toPaths.length === 0) {
-                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target." /* NotMappingPathWithEmptyMap */, { path: fromPath }));
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
                 continue;
             }
-            // split with '*'
             var segments = fromPath.split(/\*/g);
             if (segments.length === 1) {
-                var paths = toPaths.map(function (target) { return "" + prefix + target; });
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target;
+                });
                 pattern = "^" + escapeRegex(fromPath) + "$";
                 jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else if (segments.length === 2) {
-                var paths = toPaths.map(function (target) { return "" + prefix + target.replace(/\*/g, '$1'); });
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target.replace(/\*/g, '$1');
+                });
                 pattern = "^" + escapeRegex(segments[0]) + "(.*)" + escapeRegex(segments[1]) + "$";
                 jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else {
-                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`)." /* NotMappingMultiStarPath */, { path: fromPath }));
-                continue;
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
             }
         }
     }

package/dist/constants.d.ts

@@ -1 +1,2 @@
-export {};
+export declare const TS_TSX_REGEX: RegExp;
+export declare const JS_JSX_REGEX: RegExp;

package/dist/constants.js

@@ -1,28 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_JEST_TEST_MATCH = exports.JSON_REGEX = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.EXTENSION_REGEX = exports.LINE_FEED = void 0;
-/**
- * @internal
- */
+exports.DEFAULT_JEST_TEST_MATCH = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.LINE_FEED = void 0;
 exports.LINE_FEED = '\n';
-/**
- * @internal
- */
-exports.EXTENSION_REGEX = /\.[^.]+$/;
-/**
- * @internal
- */
 exports.TS_TSX_REGEX = /\.tsx?$/;
-/**
- * @internal
- */
 exports.JS_JSX_REGEX = /\.jsx?$/;
-/**
- * @internal
- */
-exports.JSON_REGEX = /\.json$/i;
-/**
- * @internal
- * See https://jestjs.io/docs/en/configuration#testmatch-arraystring
- */
 exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { createJestPreset as createJestPresetCore } from './config/create-jest-preset';
+import { createJestPreset as createJestPresetCore } from './presets/create-jest-preset';
 import { TsJestTransformer } from './ts-jest-transformer';
 import type { TsJestGlobalOptions } from './types';
-import { mocked as mockedCore } from './util/testing';
+import { mocked as mockedCore } from './utils/testing';
 declare module '@jest/types' {
     namespace Config {
         interface ConfigGlobals {
@@ -9,127 +9,11 @@ declare module '@jest/types' {
         }
     }
 }
-/** @deprecated */
 export declare const mocked: typeof mockedCore;
-/** @deprecated */
 export declare const createJestPreset: typeof createJestPresetCore;
-/** @deprecated */
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
+    prefix: string;
 }) => {
     [key: string]: string | string[];
 } | undefined;
-export declare function createTransformer(baseConfig?: TsJestGlobalOptions): TsJestTransformer;
-declare const jestPreset: Pick<Partial<{
-    automock: boolean;
-    bail: number | boolean;
-    cache: boolean;
-    cacheDirectory: string;
-    clearMocks: boolean;
-    changedFilesWithAncestor: boolean;
-    changedSince: string;
-    collectCoverage: boolean;
-    collectCoverageFrom: string[];
-    collectCoverageOnlyFrom: {
-        [key: string]: boolean;
-    };
-    coverageDirectory: string;
-    coveragePathIgnorePatterns: string[];
-    coverageProvider: "babel" | "v8";
-    coverageReporters: import("@jest/types/build/Config").CoverageReporters;
-    coverageThreshold: {
-        global: {
-            [key: string]: number;
-        };
-    };
-    dependencyExtractor: string;
-    detectLeaks: boolean;
-    detectOpenHandles: boolean;
-    displayName: string | import("@jest/types/build/Config").DisplayName;
-    expand: boolean;
-    extraGlobals: string[];
-    filter: string;
-    findRelatedTests: boolean;
-    forceCoverageMatch: string[];
-    forceExit: boolean;
-    json: boolean;
-    globals: import("@jest/types/build/Config").ConfigGlobals;
-    globalSetup: string | null | undefined;
-    globalTeardown: string | null | undefined;
-    haste: import("@jest/types/build/Config").HasteConfig;
-    reporters: (string | import("@jest/types/build/Config").ReporterConfig)[];
-    logHeapUsage: boolean;
-    lastCommit: boolean;
-    listTests: boolean;
-    mapCoverage: boolean;
-    maxConcurrency: number;
-    maxWorkers: string | number;
-    moduleDirectories: string[];
-    moduleFileExtensions: string[];
-    moduleLoader: string;
-    moduleNameMapper: {
-        [key: string]: string | string[];
-    };
-    modulePathIgnorePatterns: string[];
-    modulePaths: string[];
-    name: string;
-    noStackTrace: boolean;
-    notify: boolean;
-    notifyMode: string;
-    onlyChanged: boolean;
-    outputFile: string;
-    passWithNoTests: boolean;
-    preprocessorIgnorePatterns: string[];
-    preset: string | null | undefined;
-    prettierPath: string | null | undefined;
-    projects: string[];
-    replname: string | null | undefined;
-    resetMocks: boolean;
-    resetModules: boolean;
-    resolver: string | null | undefined;
-    restoreMocks: boolean;
-    rootDir: string;
-    roots: string[];
-    runner: string;
-    runTestsByPath: boolean;
-    scriptPreprocessor: string;
-    setupFiles: string[];
-    setupTestFrameworkScriptFile: string;
-    setupFilesAfterEnv: string[];
-    silent: boolean;
-    skipFilter: boolean;
-    skipNodeResolution: boolean;
-    slowTestThreshold: number;
-    snapshotResolver: string;
-    snapshotSerializers: string[];
-    errorOnDeprecated: boolean;
-    testEnvironment: string;
-    testEnvironmentOptions: Record<string, any>;
-    testFailureExitCode: string | number;
-    testLocationInResults: boolean;
-    testMatch: string[];
-    testNamePattern: string;
-    testPathDirs: string[];
-    testPathIgnorePatterns: string[];
-    testRegex: string | string[];
-    testResultsProcessor: string;
-    testRunner: string;
-    testSequencer: string;
-    testURL: string;
-    testTimeout: number;
-    timers: "real" | "fake";
-    transform: {
-        [regex: string]: string | import("@jest/types/build/Config").TransformerConfig;
-    };
-    transformIgnorePatterns: string[];
-    watchPathIgnorePatterns: string[];
-    unmockedModulePathPatterns: string[];
-    updateSnapshot: boolean;
-    useStderr: boolean;
-    verbose?: boolean | undefined;
-    watch: boolean;
-    watchAll: boolean;
-    watchman: boolean;
-    watchPlugins: (string | [string, Record<string, any>])[];
-}>, "moduleFileExtensions" | "testMatch" | "transform">;
-export { jestPreset, };
+export declare function createTransformer(): TsJestTransformer;

package/dist/index.js

@@ -1,102 +1,24 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jestPreset = exports.__resetModule = exports.__singleton = exports.canInstrument = exports.getCacheKey = exports.process = exports.createTransformer = exports.digest = exports.version = exports.pathsToModuleNameMapper = exports.createJestPreset = exports.mocked = void 0;
+exports.createTransformer = exports.pathsToModuleNameMapper = exports.createJestPreset = exports.mocked = void 0;
 var bs_logger_1 = require("bs-logger");
-var fs_1 = require("fs");
-var path_1 = require("path");
-var create_jest_preset_1 = require("./config/create-jest-preset");
+var create_jest_preset_1 = require("./presets/create-jest-preset");
 var paths_to_module_name_mapper_1 = require("./config/paths-to-module-name-mapper");
 var ts_jest_transformer_1 = require("./ts-jest-transformer");
-var logger_1 = require("./util/logger");
-var messages_1 = require("./util/messages");
-var testing_1 = require("./util/testing");
-var version_checkers_1 = require("./util/version-checkers");
-// deprecate helpers
+var logger_1 = require("./utils/logger");
+var messages_1 = require("./utils/messages");
+var testing_1 = require("./utils/testing");
+var version_checkers_1 = require("./utils/version-checkers");
 var warn = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.warn, _a));
 var helperMoved = function (name, helper) {
-    return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead." /* HelperMovedToUtils */, { helper: name }), helper);
+    return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.", { helper: name }), helper);
 };
-/** @deprecated */
 exports.mocked = helperMoved('mocked', testing_1.mocked);
-/** @deprecated */
 exports.createJestPreset = helperMoved('createJestPreset', create_jest_preset_1.createJestPreset);
-/** @deprecated */
 exports.pathsToModuleNameMapper = helperMoved('pathsToModuleNameMapper', paths_to_module_name_mapper_1.pathsToModuleNameMapper);
-/**
- * @internal
- */
-exports.version = require('../package.json').version;
-/**
- * @internal
- */
-exports.digest = fs_1.readFileSync(path_1.resolve(__dirname, '..', '.ts-jest-digest'), 'utf8');
-var transformer;
-function defaultTransformer() {
-    return transformer || (transformer = createTransformer());
-}
-function createTransformer(baseConfig) {
+function createTransformer() {
     version_checkers_1.VersionCheckers.jest.warn();
-    return new ts_jest_transformer_1.TsJestTransformer(baseConfig);
+    return new ts_jest_transformer_1.TsJestTransformer();
 }
 exports.createTransformer = createTransformer;
-/**
- * @internal
- */
-function process() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).process.apply(_a, __spread(args));
-}
-exports.process = process;
-/**
- * @internal
- */
-function getCacheKey() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).getCacheKey.apply(_a, __spread(args));
-}
-exports.getCacheKey = getCacheKey;
-/**
- * @internal
- */
-// we let jest doing the instrumentation, it does it well
-exports.canInstrument = false;
-var jestPreset = create_jest_preset_1.createJestPreset();
-exports.jestPreset = jestPreset;
-/**
- * @internal
- */
-// for tests
-exports.__singleton = function () { return transformer; };
-/**
- * @internal
- */
-exports.__resetModule = function () { return (transformer = undefined); };

package/dist/{config → presets}/create-jest-preset.d.ts

@@ -1,6 +1,7 @@
 import type { Config } from '@jest/types';
 export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
-export interface CreateJestPresetOptions {
+interface CreateJestPresetOptions {
     allowJs?: boolean;
 }
 export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;
+export {};

package/dist/{config → presets}/create-jest-preset.js

@@ -12,7 +12,7 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJestPreset = void 0;
-var logger_1 = require("../util/logger");
+var logger_1 = require("../utils/logger");
 var logger = logger_1.rootLogger.child({ namespace: 'jest-preset' });
 function createJestPreset(_a, from) {
     var _b;

package/dist/transformers/hoist-jest.js

@@ -32,83 +32,53 @@ var __spread = (this && this.__spread) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = exports.version = exports.name = void 0;
-// take care of including ONLY TYPES here, for the rest use `ts`
 var bs_logger_1 = require("bs-logger");
-/**
- * What methods of `jest` should we hoist
- */
 var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
-/**
- * @internal
- */
+var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
+var JEST_GLOBAL_NAME = 'jest';
+var ROOT_LEVEL_AST = 1;
 exports.name = 'hoisting-jest-mock';
-// increment this each time the code is modified
-/**
- * @internal
- */
-exports.version = 1;
-/**
- * The factory of hoisting transformer factory
- *
- * @param cs Current jest configuration-set
- * @internal
- */
+exports.version = 4;
 function factory(cs) {
     var logger = cs.logger.child({ namespace: 'ts-hoisting' });
-    /**
-     * Our compiler (typescript, or a module with typescript-like interface)
-     * To access Program or TypeChecker, do: cs.tsCompiler.program or cs.tsCompiler.program.getTypeChecker()
-     */
     var ts = cs.compilerModule;
-    function shouldHoistExpression(expression) {
-        return (ts.isCallExpression(expression) &&
-            ts.isPropertyAccessExpression(expression.expression) &&
-            HOIST_METHODS.includes(expression.expression.name.text) &&
-            ((ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === 'jest') ||
-                shouldHoistExpression(expression.expression.expression)));
+    var importNames = [];
+    function shouldHoistExpression(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            HOIST_METHODS.includes(node.expression.name.text)) {
+            if (importNames.length) {
+                return ((ts.isIdentifier(node.expression.expression) && importNames.includes(node.expression.expression.text)) ||
+                    (ts.isPropertyAccessExpression(node.expression.expression) &&
+                        ts.isIdentifier(node.expression.expression.expression) &&
+                        importNames.includes(node.expression.expression.expression.text)) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+            else {
+                return ((ts.isIdentifier(node.expression.expression) && node.expression.expression.text === JEST_GLOBAL_NAME) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+        }
+        return false;
     }
-    /**
-     * Checks whether given node is a statement that we need to hoist
-     *
-     * @param node The node to test
-     */
     function shouldHoistNode(node) {
         return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
     }
-    /**
-     * Create a source file visitor which will visit all nodes in a source file
-     *
-     * @param ctx The typescript transformation context
-     * @param sf The owning source file
-     */
+    function isJestGlobalImport(node) {
+        return (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === JEST_GLOBALS_MODULE_NAME);
+    }
     function createVisitor(ctx, _) {
-        /**
-         * Current block level
-         */
         var level = 0;
-        /**
-         * List of nodes which needs to be hoisted, indexed by their owning level
-         */
         var hoisted = [];
-        /**
-         * Called when we enter a block to increase the level
-         */
         var enter = function () {
             level++;
-            // reuse arrays
             if (hoisted[level]) {
                 hoisted[level].splice(0, hoisted[level].length);
             }
         };
-        /**
-         * Called when we leave a block to decrease the level
-         */
         var exit = function () { return level--; };
-        /**
-         * Adds a node to the list of nodes to be hoisted in the current level
-         *
-         * @param node The node to hoist
-         */
         var hoist = function (node) {
             if (hoisted[level]) {
                 hoisted[level].push(node);
@@ -117,37 +87,42 @@ function factory(cs) {
                 hoisted[level] = [node];
             }
         };
-        /**
-         * Our main visitor, which will be called recursively for each node in the source file's AST
-         *
-         * @param node The node to be visited
-         */
         var visitor = function (node) {
-            // enter this level
+            var _a, _b;
             enter();
-            // visit each child
             var resultNode = ts.visitEachChild(node, visitor, ctx);
-            // check if we have something to hoist in this level
+            if (isJestGlobalImport(resultNode) && ((_a = resultNode.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
+                (ts.isNamespaceImport(resultNode.importClause.namedBindings) ||
+                    ts.isNamedImports(resultNode.importClause.namedBindings))) {
+                var namedBindings = resultNode.importClause.namedBindings;
+                var jestImportName = ts.isNamespaceImport(namedBindings)
+                    ? namedBindings.name.text
+                    : (_b = namedBindings.elements.find(function (element) { var _a; return element.name.text === JEST_GLOBAL_NAME || ((_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text) === JEST_GLOBAL_NAME; })) === null || _b === void 0 ? void 0 : _b.name.text;
+                if (jestImportName) {
+                    importNames.push(jestImportName);
+                }
+            }
             if (hoisted[level] && hoisted[level].length) {
-                // re-order children so that hoisted ones appear first
-                // this is actually the main job of this transformer
                 var hoistedStmts_1 = hoisted[level];
-                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s); });
+                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s) && !isJestGlobalImport(s); });
                 var newNode = ts.getMutableClone(resultNode);
-                resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(__spread(hoistedStmts_1, otherStmts)) });
+                var newStatements = __spread(hoistedStmts_1, otherStmts);
+                if (level === ROOT_LEVEL_AST) {
+                    var jestGlobalsImportStmts = resultNode.statements.filter(function (s) { return isJestGlobalImport(s); });
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(__spread(jestGlobalsImportStmts, newStatements)) });
+                }
+                else {
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(newStatements) });
+                }
             }
-            // exit the level
             exit();
             if (shouldHoistNode(resultNode)) {
-                // hoist into current level
                 hoist(resultNode);
             }
-            // finally returns the currently visited node
             return resultNode;
         };
         return visitor;
     }
-    // returns the transformer factory
     return function (ctx) {
         var _a;
         return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): hoisting', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });

package/dist/transformers/index.js

@@ -1,8 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.internals = void 0;
-var hoisting = require("./hoist-jest");
-/**
- * @internal
- */
+var hoisting = __importStar(require("./hoist-jest"));
 exports.internals = [hoisting];

package/dist/transformers/path-mapping.d.ts

@@ -0,0 +1,3 @@
+import type * as _ts from 'typescript';
+import type { ConfigSet } from '../config/config-set';
+export declare function factory(cs: ConfigSet): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;