import { relative , basename , extname , resolve , dirname , join } from 'path' ; import sourceMapSupport = require ( 'source-map-support' ) ; import * as ynModule from 'yn' ; import { BaseError } from 'make-error' ; import * as util from 'util' ; import * as _ts from 'typescript' ; /**
 * Does this version of node obey the package.json "type" field
 * and throw ERR_REQUIRE_ESM when attempting to require() an ESM modules.
 */ const engineSupportsPackageTypeField = parseInt ( process . versions . node . split ( '.' ) [ 0 ] , 10 ) >= 12 ; let assertScriptCanLoadAsCJSImpl ; /**
 * Assert that script can be loaded as CommonJS when we attempt to require it.
 * If it should be loaded as ESM, throw ERR_REQUIRE_ESM like node does.
 */ function assertScriptCanLoadAsCJS ( filename ) { if ( ! engineSupportsPackageTypeField ) { return ; } if ( ! assertScriptCanLoadAsCJSImpl ) { assertScriptCanLoadAsCJSImpl = require ( '../dist-raw/node-cjs-loader-utils' ) . assertScriptCanLoadAsCJSImpl ; } assertScriptCanLoadAsCJSImpl ! ( filename ) ; } /**
 * Registered `ts-node` instance information.
 */ export const REGISTER_INSTANCE = Symbol . for ( 'ts-node.register.instance' ) ; /**
 * Expose `REGISTER_INSTANCE` information on node.js `process`.
 */ declare global { namespace NodeJS { interface Process { [ REGISTER_INSTANCE ] ? : Register ; } } } internal export const INSPECT_CUSTOM = util . inspect . custom || 'inspect' ; /**
 * Wrapper around yn module that returns `undefined` instead of `null`.
 * This is implemented by yn v4, but we're staying on v3 to avoid v4's node 10 requirement.
 */ function yn ( value ) { return ynModule ( value ) ?? undefined ; } /**
 * Debugging `ts-node`.
 */ const shouldDebug = yn ( process . env . TS_NODE_DEBUG ) ; internal export const debug = shouldDebug ? ( ... args ) => console . log ( `[ts-node ${ new Date ( ) . toISOString ( ) }]` , ... args ) : ( ) => undefined ; const debugFn = shouldDebug ? < T , U > ( key , fn ) => { let i = 0 ; return ( x ) => { debug ( key , x , ++ i ) ; return fn ( x ) ; } ; } : < T , U > ( _ , fn ) => fn ; /**
 * Common TypeScript interfaces between versions.
 */ export interface TSCommon { version : typeof _ts . version ; sys : typeof _ts . sys ; ScriptSnapshot : typeof _ts . ScriptSnapshot ; displayPartsToString : typeof _ts . displayPartsToString ; createLanguageService : typeof _ts . createLanguageService ; getDefaultLibFilePath : typeof _ts . getDefaultLibFilePath ; getPreEmitDiagnostics : typeof _ts . getPreEmitDiagnostics ; flattenDiagnosticMessageText : typeof _ts . flattenDiagnosticMessageText ; transpileModule : typeof _ts . transpileModule ; ModuleKind : typeof _ts . ModuleKind ; ScriptTarget : typeof _ts . ScriptTarget ; findConfigFile : typeof _ts . findConfigFile ; readConfigFile : typeof _ts . readConfigFile ; parseJsonConfigFileContent : typeof _ts . parseJsonConfigFileContent ; formatDiagnostics : typeof _ts . formatDiagnostics ; formatDiagnosticsWithColorAndContext : typeof _ts . formatDiagnosticsWithColorAndContext ; } /**
 * Export the current version.
 */ export const VERSION = require ( '../package.json' ) . version ; /**
 * Options for creating a new TypeScript compiler instance.
 */ export interface CreateOptions { default dir ? : string ; default emit ? : boolean ; default scope ? : boolean ; default pretty ? : boolean ; default transpileOnly ? : boolean ; default typeCheck ? : boolean ; default compilerHost ? : boolean ; default logError ? : boolean ; default files ? : boolean ; default compiler ? : string ; default docsDefault ignore ? : string [ ] ; /**
     * Path to TypeScript JSON project file.
     */ project ? : string ; default skipProject ? : boolean ; default skipIgnore ? : boolean ; allOf compilerOptions ? : object ; /**
     * Ignore TypeScript warnings by diagnostic code.
     */ ignoreDiagnostics ? : Array < number | string > ; readFile ? : ( path : string ) => string | undefined ; fileExists ? : ( path : string ) => boolean ; transformers ? : _ts . CustomTransformers | ( ( p : _ts . Program ) => _ts . CustomTransformers ) ; internal experimentalEsmLoader ? : boolean ; } /**
 * Options for registering a TypeScript compiler instance globally.
 */ export interface RegisterOptions extends CreateOptions { default preferTsExts ? : boolean ; } /**
 * Must be an interface to support `typescript-json-schema`.
 */ export interface TsConfigOptions extends Omit < RegisterOptions , 'transformers' | 'readFile' | 'fileExists' | 'skipProject' | 'project' | 'dir' > { } /**
 * Like `Object.assign`, but ignores `undefined` properties.
 */ function assign < T extends object > ( initialValue , ... sources ) { for ( const source of sources ) { for ( const key of Object . keys ( source ) ) { const value = ( source as any ) [ key ] ; if ( value !== undefined ) { ( initialValue as any ) [ key ] = value ; } } } return initialValue ; } /**
 * Information retrieved from type info check.
 */ export interface TypeInfo { name : string ; comment : string ; } /**
 * Default register options, including values specified via environment
 * variables.
 */ export const DEFAULTS = { dir : process . env . TS_NODE_DIR , emit : yn ( process . env . TS_NODE_EMIT ) , scope : yn ( process . env . TS_NODE_SCOPE ) , files : yn ( process . env . TS_NODE_FILES ) , pretty : yn ( process . env . TS_NODE_PRETTY ) , compiler : process . env . TS_NODE_COMPILER , compilerOptions : parse ( process . env . TS_NODE_COMPILER_OPTIONS ) , ignore : split ( process . env . TS_NODE_IGNORE ) , project : process . env . TS_NODE_PROJECT , skipProject : yn ( process . env . TS_NODE_SKIP_PROJECT ) , skipIgnore : yn ( process . env . TS_NODE_SKIP_IGNORE ) , preferTsExts : yn ( process . env . TS_NODE_PREFER_TS_EXTS ) , ignoreDiagnostics : split ( process . env . TS_NODE_IGNORE_DIAGNOSTICS ) , transpileOnly : yn ( process . env . TS_NODE_TRANSPILE_ONLY ) , typeCheck : yn ( process . env . TS_NODE_TYPE_CHECK ) , compilerHost : yn ( process . env . TS_NODE_COMPILER_HOST ) , logError : yn ( process . env . TS_NODE_LOG_ERROR ) , experimentalEsmLoader : false } ; /**
 * Default TypeScript compiler options required by `ts-node`.
 */ const TS_NODE_COMPILER_OPTIONS = { sourceMap : true , inlineSourceMap : false , inlineSources : true , declaration : false , noEmit : false , outDir : '.ts-node' } ; /**
 * Split a string array of values.
 */ export function split ( value ) { return typeof value === 'string' ? value . split ( / *, */g ) : undefined ; } /**
 * Parse a string as JSON.
 */ export function parse ( value ) { return typeof value === 'string' ? JSON . parse ( value ) : undefined ; } /**
 * Replace backslashes with forward slashes.
 */ export function normalizeSlashes ( value ) { return value . replace ( /\\/g , '/' ) ; } /**
 * TypeScript diagnostics error.
 */ export class TSError extends BaseError { name = 'TSError' ; constructor ( public diagnosticText , public diagnosticCodes ) { super ( `⨯ Unable to compile TypeScript:\n${ diagnosticText }` ) ; } internal [ INSPECT_CUSTOM ] ( ) { return this . diagnosticText ; } } /**
 * Return type for registering `ts-node`.
 */ export interface Register { ts : TSCommon ; config : _ts . ParsedCommandLine ; options : RegisterOptions ; enabled ( enabled ? ) : boolean ; ignored ( fileName ) : boolean ; compile ( code , fileName , lineOffset ? ) : string ; getTypeInfo ( code , fileName , position ) : TypeInfo ; } /**
 * Cached fs operation wrapper.
 */ function cachedLookup < T > ( fn ) { const cache = new Map < string , T > ( ) ; return ( arg ) : T => { if ( ! cache . has ( arg ) ) { cache . set ( arg , fn ( arg ) ) ; } return cache . get ( arg ) ! ; } ; } internal export function getExtensions ( config ) { const tsExtensions = [ '.ts' ] ; const jsExtensions = [ ] ; if ( config . options . jsx ) { tsExtensions . push ( '.tsx' ) ; } if ( config . options . allowJs ) { jsExtensions . push ( '.js' ) ; } if ( config . options . jsx && config . options . allowJs ) { jsExtensions . push ( '.jsx' ) ; } return { tsExtensions , jsExtensions } ; } /**
 * Register TypeScript compiler instance onto node.js
 */ export function register ( opts = { } ) { const originalJsHandler = require . extensions [ '.js' ] ; const service = create ( opts ) ; const { tsExtensions , jsExtensions } = getExtensions ( service . config ) ; const extensions = [ ... tsExtensions , ... jsExtensions ] ; process [ REGISTER_INSTANCE ] = service ; registerExtensions ( service . options . preferTsExts , extensions , service , originalJsHandler ) ; return service ; } /**
 * Create TypeScript compiler instance.
 */ export function create ( rawOptions = { } ) { const dir = rawOptions . dir ?? DEFAULTS . dir ; const compilerName = rawOptions . compiler ?? DEFAULTS . compiler ; const cwd = dir ? resolve ( dir ) : process . cwd ( ) ; /**
     * Load the typescript compiler. It is required to load the tsconfig but might
     * be changed by the tsconfig, so we sometimes have to do this twice.
     */ function loadCompiler ( name ) { const compiler = require . resolve ( name || 'typescript' , { paths : [ cwd , __dirname ] } ) ; const ts = require ( compiler ) ; return { compiler , ts } ; } let { compiler , ts } = loadCompiler ( compilerName ) ; const { config , options : tsconfigOptions } = readConfig ( cwd , ts , rawOptions ) ; const options = assign < CreateOptions > ( { } , DEFAULTS , tsconfigOptions || { } , rawOptions ) ; if ( options . compiler !== compilerName ) { ( { compiler , ts } = loadCompiler ( options . compiler ) ) ; } const readFile = options . readFile || ts . sys . readFile ; const fileExists = options . fileExists || ts . sys . fileExists ; const transpileOnly = options . transpileOnly === true || options . typeCheck === false ; const transformers = options . transformers || undefined ; const ignoreDiagnostics = [ 6059 , 18002 , 18003 , ... ( options . ignoreDiagnostics || [ ] ) ] . map ( Number ) ; const configDiagnosticList = filterDiagnostics ( config . errors , ignoreDiagnostics ) ; const outputCache = new Map < string , { content : string ; } > ( ) ; const isScoped = options . scope ? ( relname ) => relname . charAt ( 0 ) !== '.' : ( ) => true ; const shouldIgnore = createIgnore ( options . skipIgnore ? [ ] : ( options . ignore || [ '(?:^|/)node_modules/' ] ) . map ( str => new RegExp ( str ) ) ) ; const diagnosticHost = { getNewLine : ( ) => ts . sys . newLine , getCurrentDirectory : ( ) => cwd , getCanonicalFileName : ts . sys . useCaseSensitiveFileNames ? x => x : x => x . toLowerCase ( ) } ; sourceMapSupport . install ( { environment : 'node' , retrieveFile ( path ) { return outputCache . get ( normalizeSlashes ( path ) ) ?. content || '' ; } } ) ; const formatDiagnostics = process . stdout . isTTY || options . pretty ? ( ts . formatDiagnosticsWithColorAndContext || ts . formatDiagnostics ) : ts . formatDiagnostics ; function createTSError ( diagnostics ) { const diagnosticText = formatDiagnostics ( diagnostics , diagnosticHost ) ; const diagnosticCodes = diagnostics . map ( x => x . code ) ; return new TSError ( diagnosticText , diagnosticCodes ) ; } function reportTSError ( configDiagnosticList ) { const error = createTSError ( configDiagnosticList ) ; if ( options . logError ) { console . error ( '\x1b[31m%s\x1b[0m' , error ) ; } else { throw error ; } } if ( configDiagnosticList . length ) { reportTSError ( configDiagnosticList ) ; } /**
     * Get the extension for a transpiled file.
     */ const getExtension = config . options . jsx === ts . JsxEmit . Preserve ? ( ( path ) => /\.[tj]sx$/ . test ( path ) ? '.jsx' : '.js' ) : ( ( _ ) => '.js' ) ; /**
     * Create the basic required function using transpile mode.
     */ let getOutput ; let getTypeInfo ; if ( ! transpileOnly ) { const fileContents = new Map < string , string > ( ) ; const rootFileNames = new Set ( config . fileNames ) ; const cachedReadFile = cachedLookup ( debugFn ( 'readFile' , readFile ) ) ; if ( ! options . compilerHost ) { let projectVersion = 1 ; const fileVersions = new Map ( Array . from ( rootFileNames ) . map ( fileName => [ fileName , 0 ] ) ) ; const getCustomTransformers = ( ) => { if ( typeof transformers === 'function' ) { const program = service . getProgram ( ) ; return program ? transformers ( program ) : undefined ; } return transformers ; } ; const serviceHost = { getProjectVersion : ( ) => String ( projectVersion ) , getScriptFileNames : ( ) => Array . from ( rootFileNames ) , getScriptVersion : ( fileName ) => { const version = fileVersions . get ( fileName ) ; return version ? version . toString ( ) : '' ; } , getScriptSnapshot ( fileName ) { let contents = fileContents . get ( fileName ) ; if ( contents === undefined ) { contents = cachedReadFile ( fileName ) ; if ( contents === undefined ) { return ; } fileVersions . set ( fileName , 1 ) ; fileContents . set ( fileName , contents ) ; projectVersion ++ ; } return ts . ScriptSnapshot . fromString ( contents ) ; } , readFile : cachedReadFile , readDirectory : ts . sys . readDirectory , getDirectories : cachedLookup ( debugFn ( 'getDirectories' , ts . sys . getDirectories ) ) , fileExists : cachedLookup ( debugFn ( 'fileExists' , fileExists ) ) , directoryExists : cachedLookup ( debugFn ( 'directoryExists' , ts . sys . directoryExists ) ) , getNewLine : ( ) => ts . sys . newLine , useCaseSensitiveFileNames : ( ) => ts . sys . useCaseSensitiveFileNames , getCurrentDirectory : ( ) => cwd , getCompilationSettings : ( ) => config . options , getDefaultLibFileName : ( ) => ts . getDefaultLibFilePath ( config . options ) , getCustomTransformers } ; const registry = ts . createDocumentRegistry ( ts . sys . useCaseSensitiveFileNames , cwd ) ; const service = ts . createLanguageService ( serviceHost , registry ) ; const updateMemoryCache = ( contents , fileName ) => { if ( ! rootFileNames . has ( fileName ) ) { rootFileNames . add ( fileName ) ; projectVersion ++ ; } const previousVersion = fileVersions . get ( fileName ) || 0 ; const previousContents = fileContents . get ( fileName ) ; if ( contents !== previousContents ) { fileVersions . set ( fileName , previousVersion + 1 ) ; fileContents . set ( fileName , contents ) ; projectVersion ++ ; } } ; let previousProgram ; getOutput = ( code , fileName ) => { updateMemoryCache ( code , fileName ) ; const programBefore = service . getProgram ( ) ; if ( programBefore !== previousProgram ) { debug ( `compiler rebuilt Program instance when getting output for ${ fileName }` ) ; } const output = service . getEmitOutput ( fileName ) ; const diagnostics = service . getSemanticDiagnostics ( fileName ) . concat ( service . getSyntacticDiagnostics ( fileName ) ) ; const programAfter = service . getProgram ( ) ; debug ( 'invariant: Is service.getProject() identical before and after getting emit output and diagnostics? (should always be true) ' , programBefore === programAfter ) ; previousProgram = programAfter ; const diagnosticList = filterDiagnostics ( diagnostics , ignoreDiagnostics ) ; if ( diagnosticList . length ) { reportTSError ( diagnosticList ) ; } if ( output . emitSkipped ) { throw new TypeError ( `${ relative ( cwd , fileName ) }: Emit skipped` ) ; } if ( output . outputFiles . length === 0 ) { throw new TypeError ( `Unable to require file: ${ relative ( cwd , fileName ) }\n` + 'This is usually the result of a faulty configuration or import. ' + 'Make sure there is a `.js`, `.json` or other executable extension with ' + 'loader attached before `ts-node` available.' ) ; } return [ output . outputFiles [ 1 ] . text , output . outputFiles [ 0 ] . text ] ; } ; getTypeInfo = ( code , fileName , position ) => { updateMemoryCache ( code , fileName ) ; const info = service . getQuickInfoAtPosition ( fileName , position ) ; const name = ts . displayPartsToString ( info ? info . displayParts : [ ] ) ; const comment = ts . displayPartsToString ( info ? info . documentation : [ ] ) ; return { name , comment } ; } ; } else { const sys = { ... ts . sys , ... diagnosticHost , readFile : ( fileName ) => { const cacheContents = fileContents . get ( fileName ) ; if ( cacheContents !== undefined ) { return cacheContents ; } return cachedReadFile ( fileName ) ; } , readDirectory : ts . sys . readDirectory , getDirectories : cachedLookup ( debugFn ( 'getDirectories' , ts . sys . getDirectories ) ) , fileExists : cachedLookup ( debugFn ( 'fileExists' , fileExists ) ) , directoryExists : cachedLookup ( debugFn ( 'directoryExists' , ts . sys . directoryExists ) ) , resolvePath : cachedLookup ( debugFn ( 'resolvePath' , ts . sys . resolvePath ) ) , realpath : ts . sys . realpath ? cachedLookup ( debugFn ( 'realpath' , ts . sys . realpath ) ) : undefined } ; const host = ts . createIncrementalCompilerHost ? ts . createIncrementalCompilerHost ( config . options , sys ) : { ... sys , getSourceFile : ( fileName , languageVersion ) => { const contents = sys . readFile ( fileName ) ; if ( contents === undefined ) { return ; } return ts . createSourceFile ( fileName , contents , languageVersion ) ; } , getDefaultLibLocation : ( ) => normalizeSlashes ( dirname ( compiler ) ) , getDefaultLibFileName : ( ) => normalizeSlashes ( join ( dirname ( compiler ) , ts . getDefaultLibFileName ( config . options ) ) ) , useCaseSensitiveFileNames : ( ) => sys . useCaseSensitiveFileNames } ; let builderProgram = ts . createIncrementalProgram ? ts . createIncrementalProgram ( { rootNames : Array . from ( rootFileNames ) , options : config . options , host , configFileParsingDiagnostics : config . errors , projectReferences : config . projectReferences } ) : ts . createEmitAndSemanticDiagnosticsBuilderProgram ( Array . from ( rootFileNames ) , config . options , host , undefined , config . errors , config . projectReferences ) ; const customTransformers = typeof transformers === 'function' ? transformers ( builderProgram . getProgram ( ) ) : transformers ; const updateMemoryCache = ( contents , fileName ) => { const sourceFile = builderProgram . getSourceFile ( fileName ) ; fileContents . set ( fileName , contents ) ; if ( sourceFile === undefined ) { rootFileNames . add ( fileName ) ; } if ( sourceFile === undefined || sourceFile . text !== contents ) { builderProgram = ts . createEmitAndSemanticDiagnosticsBuilderProgram ( Array . from ( rootFileNames ) , config . options , host , builderProgram , config . errors , config . projectReferences ) ; } } ; getOutput = ( code , fileName ) => { const output = [ '' , '' ] ; updateMemoryCache ( code , fileName ) ; const sourceFile = builderProgram . getSourceFile ( fileName ) ; if ( ! sourceFile ) { throw new TypeError ( `Unable to read file: ${ fileName }` ) ; } const program = builderProgram . getProgram ( ) ; const diagnostics = ts . getPreEmitDiagnostics ( program , sourceFile ) ; const diagnosticList = filterDiagnostics ( diagnostics , ignoreDiagnostics ) ; if ( diagnosticList . length ) { reportTSError ( diagnosticList ) ; } const result = builderProgram . emit ( sourceFile , ( path , file , writeByteOrderMark ) => { if ( path . endsWith ( '.map' ) ) { output [ 1 ] = file ; } else { output [ 0 ] = file ; } if ( options . emit ) { sys . writeFile ( path , file , writeByteOrderMark ) ; } } , undefined , undefined , customTransformers ) ; if ( result . emitSkipped ) { throw new TypeError ( `${ relative ( cwd , fileName ) }: Emit skipped` ) ; } if ( output [ 0 ] === '' ) { if ( program . isSourceFileFromExternalLibrary ( sourceFile ) ) { throw new TypeError ( `Unable to compile file from external library: ${ relative ( cwd , fileName ) }` ) ; } throw new TypeError ( `Unable to require file: ${ relative ( cwd , fileName ) }\n` + 'This is usually the result of a faulty configuration or import. ' + 'Make sure there is a `.js`, `.json` or other executable extension with ' + 'loader attached before `ts-node` available.' ) ; } return output ; } ; getTypeInfo = ( code , fileName , position ) => { updateMemoryCache ( code , fileName ) ; const sourceFile = builderProgram . getSourceFile ( fileName ) ; if ( ! sourceFile ) { throw new TypeError ( `Unable to read file: ${ fileName }` ) ; } const node = getTokenAtPosition ( ts , sourceFile , position ) ; const checker = builderProgram . getProgram ( ) . getTypeChecker ( ) ; const symbol = checker . getSymbolAtLocation ( node ) ; if ( ! symbol ) { return { name : '' , comment : '' } ; } const type = checker . getTypeOfSymbolAtLocation ( symbol , node ) ; const signatures = [ ... type . getConstructSignatures ( ) , ... type . getCallSignatures ( ) ] ; return { name : signatures . length ? signatures . map ( x => checker . signatureToString ( x ) ) . join ( '\n' ) : checker . typeToString ( type ) , comment : ts . displayPartsToString ( symbol ? symbol . getDocumentationComment ( checker ) : [ ] ) } ; } ; if ( options . emit && config . options . incremental ) { process . on ( 'exit' , ( ) => { ( builderProgram . getProgram ( ) as any ) . emitBuildInfo ( ) ; } ) ; } } } else { if ( typeof transformers === 'function' ) { throw new TypeError ( 'Transformers function is unavailable in "--transpile-only"' ) ; } getOutput = ( code , fileName ) : SourceOutput => { const result = ts . transpileModule ( code , { fileName , compilerOptions : config . options , reportDiagnostics : true , transformers } ) ; const diagnosticList = filterDiagnostics ( result . diagnostics || [ ] , ignoreDiagnostics ) ; if ( diagnosticList . length ) { reportTSError ( diagnosticList ) ; } return [ result . outputText , result . sourceMapText as string ] ; } ; getTypeInfo = ( ) => { throw new TypeError ( 'Type information is unavailable in "--transpile-only"' ) ; } ; } function compile ( code , fileName , lineOffset = 0 ) { const normalizedFileName = normalizeSlashes ( fileName ) ; const [ value , sourceMap ] = getOutput ( code , normalizedFileName ) ; const output = updateOutput ( value , normalizedFileName , sourceMap , getExtension ) ; outputCache . set ( normalizedFileName , { content : output } ) ; return output ; } let active = true ; const enabled = ( enabled ? ) => enabled === undefined ? active : ( active = ! ! enabled ) ; const ignored = ( fileName ) => { if ( ! active ) { return true ; } const relname = relative ( cwd , fileName ) ; if ( ! config . options . allowJs ) { const ext = extname ( fileName ) ; if ( ext === '.js' || ext === '.jsx' ) { return true ; } } return ! isScoped ( relname ) || shouldIgnore ( relname ) ; } ; return { ts , config , compile , getTypeInfo , ignored , enabled , options } ; } /**
 * Check if the filename should be ignored.
 */ function createIgnore ( ignore ) { return ( relname ) => { const path = normalizeSlashes ( relname ) ; return ignore . some ( x => x . test ( path ) ) ; } ; } param { string } ext function reorderRequireExtension ( ext ) { const old = require . extensions [ ext ] ; delete require . extensions [ ext ] ; require . extensions [ ext ] = old ; } /**
 * Register the extensions to support when importing files.
 */ function registerExtensions ( preferTsExts , extensions , register , originalJsHandler ) { for ( const ext of extensions ) { registerExtension ( ext , register , originalJsHandler ) ; } if ( preferTsExts ) { const preferredExtensions = new Set ( [ ... extensions , ... Object . keys ( require . extensions ) ] ) ; for ( const ext of preferredExtensions ) { reorderRequireExtension ( ext ) ; } } } /**
 * Register the extension for node.
 */ function registerExtension ( ext , register , originalHandler ) { const old = require . extensions [ ext ] || originalHandler ; require . extensions [ ext ] = function ( m , filename ) { if ( register . ignored ( filename ) ) { return old ( m , filename ) ; } if ( register . options . experimentalEsmLoader ) { assertScriptCanLoadAsCJS ( filename ) ; } const _compile = m . _compile ; m . _compile = function ( code , fileName ) { debug ( 'module._compile' , fileName ) ; return _compile . call ( this , register . compile ( code , fileName ) , fileName ) ; } ; return old ( m , filename ) ; } ; } /**
 * Do post-processing on config options to support `ts-node`.
 */ function fixConfig ( ts , config ) { delete config . options . out ; delete config . options . outFile ; delete config . options . composite ; delete config . options . declarationDir ; delete config . options . declarationMap ; delete config . options . emitDeclarationOnly ; if ( config . options . target === undefined ) { config . options . target = ts . ScriptTarget . ES5 ; } if ( config . options . module === undefined ) { config . options . module = ts . ModuleKind . CommonJS ; } return config ; } /**
 * Load TypeScript configuration. Returns the parsed TypeScript config and
 * any `ts-node` options specified in the config file.
 */ function readConfig ( cwd , ts , rawOptions ) { let config = { compilerOptions : { } } ; let basePath = cwd ; let configFileName ; const { fileExists = ts . sys . fileExists , readFile = ts . sys . readFile , skipProject = DEFAULTS . skipProject , project = DEFAULTS . project } = rawOptions ; if ( ! skipProject ) { configFileName = project ? resolve ( cwd , project ) : ts . findConfigFile ( cwd , fileExists ) ; if ( configFileName ) { const result = ts . readConfigFile ( configFileName , readFile ) ; if ( result . error ) { return { config : { errors : [ result . error ] , fileNames : [ ] , options : { } } , options : { } } ; } config = result . config ; basePath = dirname ( configFileName ) ; } } const tsconfigOptions = Object . assign ( { } , config [ 'ts-node' ] ) ; const files = rawOptions . files ?? tsconfigOptions . files ?? DEFAULTS . files ; if ( ! files ) { config . files = [ ] ; config . include = [ ] ; } config . compilerOptions = Object . assign ( { } , config . compilerOptions , DEFAULTS . compilerOptions , tsconfigOptions . compilerOptions , rawOptions . compilerOptions , TS_NODE_COMPILER_OPTIONS ) ; const fixedConfig = fixConfig ( ts , ts . parseJsonConfigFileContent ( config , { fileExists , readFile , readDirectory : ts . sys . readDirectory , useCaseSensitiveFileNames : ts . sys . useCaseSensitiveFileNames } , basePath , undefined , configFileName ) ) ; return { config : fixedConfig , options : tsconfigOptions } ; } /**
 * Internal source output.
 */ type SourceOutput = [ string , string ] ; /**
 * Update the output remapping the source map.
 */ function updateOutput ( outputText , fileName , sourceMap , getExtension ) { const base64Map = Buffer . from ( updateSourceMap ( sourceMap , fileName ) , 'utf8' ) . toString ( 'base64' ) ; const sourceMapContent = `data:application/json;charset=utf-8;base64,${ base64Map }` ; const sourceMapLength = `${ basename ( fileName ) }.map` . length + ( getExtension ( fileName ) . length - extname ( fileName ) . length ) ; return outputText . slice ( 0 , - sourceMapLength ) + sourceMapContent ; } /**
 * Update the source map contents for improved output.
 */ function updateSourceMap ( sourceMapText , fileName ) { const sourceMap = JSON . parse ( sourceMapText ) ; sourceMap . file = fileName ; sourceMap . sources = [ fileName ] ; delete sourceMap . sourceRoot ; return JSON . stringify ( sourceMap ) ; } /**
 * Filter diagnostics.
 */ function filterDiagnostics ( diagnostics , ignore ) { return diagnostics . filter ( x => ignore . indexOf ( x . code ) === - 1 ) ; } /**
 * Get token at file position.
 *
 * Reference: https://github.com/microsoft/TypeScript/blob/fcd9334f57d85b73dd66ad2d21c02e84822f4841/src/services/utilities.ts#L705-L731
 */ function getTokenAtPosition ( ts , sourceFile , position ) { let current = sourceFile ; outer : while ( true ) { for ( const child of current . getChildren ( sourceFile ) ) { const start = child . getFullStart ( ) ; if ( start > position ) { break ; } const end = child . getEnd ( ) ; if ( position <= end ) { current = child ; continue outer ; } } return current ; } }