namespace ts.server {

export const maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;

/*@internal*/

export const maxFileSize = 4 * 1024 * 1024;

export const ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground";

export const ProjectLoadingStartEvent = "projectLoadingStart";

export const ProjectLoadingFinishEvent = "projectLoadingFinish";

export const LargeFileReferencedEvent = "largeFileReferenced";

export const ConfigFileDiagEvent = "configFileDiag";

export const ProjectLanguageServiceStateEvent = "projectLanguageServiceState";

export const ProjectInfoTelemetryEvent = "projectInfo";

export const OpenFileInfoTelemetryEvent = "openFileInfo";

export interface ProjectsUpdatedInBackgroundEvent {

eventName: typeof ProjectsUpdatedInBackgroundEvent;

data: { openFiles: string[]; };

}

export interface ProjectLoadingStartEvent {

eventName: typeof ProjectLoadingStartEvent;

data: { project: Project; reason: string; };

}

export interface ProjectLoadingFinishEvent {

eventName: typeof ProjectLoadingFinishEvent;

data: { project: Project; };

}

export interface LargeFileReferencedEvent {

eventName: typeof LargeFileReferencedEvent;

data: { file: string; fileSize: number; maxFileSize: number; };

}

export interface ConfigFileDiagEvent {

eventName: typeof ConfigFileDiagEvent;

data: { triggerFile: string, configFileName: string, diagnostics: readonly Diagnostic[] };

}

export interface ProjectLanguageServiceStateEvent {

eventName: typeof ProjectLanguageServiceStateEvent;

data: { project: Project, languageServiceEnabled: boolean };

}

/** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */

export interface ProjectInfoTelemetryEvent {

readonly eventName: typeof ProjectInfoTelemetryEvent;

readonly data: ProjectInfoTelemetryEventData;

}

/*

export interface ProjectInfoTelemetryEventData {

}

/**

export interface OpenFileInfoTelemetryEvent {

readonly eventName: typeof OpenFileInfoTelemetryEvent;

readonly data: OpenFileInfoTelemetryEventData;

}

export interface OpenFileInfoTelemetryEventData {

readonly info: OpenFileInfo;

}

export interface ProjectInfoTypeAcquisitionData {

}

export interface FileStats {

}

export interface OpenFileInfo {

readonly checkJs: boolean;

}

export type ProjectServiceEvent =

| OpenFileInfoTelemetryEvent;

export type ProjectServiceEventHandler = (event: ProjectServiceEvent) => void;

/*@internal*/

export type PerformanceEventHandler = (event: PerformanceEvent) => void;

export interface SafeList {

[name: string]: { match: RegExp, exclude?: (string | number)[][], types?: string[] };

}

function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): ESMap<string, ESMap<string, number>> {

}

const compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);

const watchOptionsConverters = prepareConvertersForEnumLikeCompilerOptions(optionsForWatch);

const indentStyle = new Map(getEntries({

none: IndentStyle.None,

block: IndentStyle.Block,

smart: IndentStyle.Smart

}));

export interface TypesMapFile {

typesMap: SafeList;

simpleMap: { [libName: string]: string };

}

/**

const defaultTypeSafeList: SafeList = {

"jquery": {

// jquery files can have names like "jquery-1.10.2.min.js" (or "jquery.intellisense.js")

match: /jquery(-(\.?\d+)+)?(\.intellisense)?(\.min)?\.js$/i,

types: ["jquery"]

},

"WinJS": {

// e.g. c:/temp/UWApp1/lib/winjs-4.0.1/js/base.js

match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i, // If the winjs/base.js file is found..

exclude: [["^", 1, "/.*"]], // ..then exclude all files under the winjs folder

types: ["winjs"] // And fetch the @types package for WinJS

},

"Kendo": {

// e.g. /Kendo3/wwwroot/lib/kendo/kendo.all.min.js

match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i,

exclude: [["^", 1, "/.*"]],

types: ["kendo-ui"]

},

"Office Nuget": {

// e.g. /scripts/Office/1/excel-15.debug.js

match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i, // Office NuGet package is installed under a "1/office" folder

exclude: [["^", 1, "/.*"]], // Exclude that whole folder if the file indicated above is found in it

types: ["office"] // @types package to fetch instead

},

"References": {

match: /^(.*\/_references\.js)$/i,

exclude: [["^", 1, "$"]]

}

};

export function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings {

}

export function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin {

}

export function convertWatchOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): WatchOptions | undefined {

}

export function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind {

return isString(scriptKindName) ? convertScriptKindName(scriptKindName) : scriptKindName;

}

export function convertScriptKindName(scriptKindName: protocol.ScriptKindName) {

}

/*@internal*/

export function convertUserPreferences(preferences: protocol.UserPreferences): UserPreferences {

const { lazyConfiguredProjectsFromExternalProject, ...userPreferences } = preferences;

return userPreferences;

}

export interface HostConfiguration {

}

export interface OpenConfiguredProjectResult {

configFileName?: NormalizedPath;

configFileErrors?: readonly Diagnostic[];

}

interface AssignProjectResult extends OpenConfiguredProjectResult {

retainProjects: readonly ConfiguredProject[] | ConfiguredProject | undefined;

}

interface FilePropertyReader<T> {

}

const fileNamePropertyReader: FilePropertyReader<string> = {

getFileName: x => x,

getScriptKind: (fileName, extraFileExtensions) => {

},

hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, ext => ext.isMixedContent && fileExtensionIs(fileName, ext.extension)),

};

const externalFilePropertyReader: FilePropertyReader<protocol.ExternalFile> = {

getFileName: x => x.fileName,

getScriptKind: x => tryConvertScriptKindName(x.scriptKind!), // TODO: GH#18217

hasMixedContent: x => !!x.hasMixedContent,

};

function findProjectByName<T extends Project>(projectName: string, projects: T[]): T | undefined {

}

const enum ConfigFileWatcherStatus {

}

/*@internal*/

interface ConfigFileExistenceInfo {

}

export interface ProjectServiceOptions {

}

interface OriginalFileInfo { fileName: NormalizedPath; path: Path; }

interface AncestorConfigFileInfo {

}

type OpenScriptInfoOrClosedFileInfo = ScriptInfo | OriginalFileInfo;

type OpenScriptInfoOrClosedOrConfigFileInfo = OpenScriptInfoOrClosedFileInfo | AncestorConfigFileInfo;

function isOpenScriptInfo(infoOrFileNameOrConfig: OpenScriptInfoOrClosedOrConfigFileInfo): infoOrFileNameOrConfig is ScriptInfo {

return !!(infoOrFileNameOrConfig as ScriptInfo).containingProjects;

}

function isAncestorConfigFileInfo(infoOrFileNameOrConfig: OpenScriptInfoOrClosedOrConfigFileInfo): infoOrFileNameOrConfig is AncestorConfigFileInfo {

return !!(infoOrFileNameOrConfig as AncestorConfigFileInfo).configFileInfo;

}

/*@internal*/

/** Kind of operation to perform to get project reference project */

export enum ProjectReferenceProjectLoadKind {

}

/*@internal*/

export function forEachResolvedProjectReferenceProject<T>(

): T | undefined;

/*@internal*/

export function forEachResolvedProjectReferenceProject<T>(

): T | undefined;

export function forEachResolvedProjectReferenceProject<T>(

}

/*@internal*/

export function forEachResolvedProjectReference<T>(

}

function forEachPotentialProjectReference<T>(

}

function forEachAnyProjectReferenceKind<T>(

}

function callbackRefProject<T>(

}

function forEachReferencedProject<T>(

}

interface ScriptInfoInNodeModulesWatcher extends FileWatcher {

refCount: number;

}

function getDetailWatchInfo(watchType: WatchType, project: Project | undefined) {

return `Project: ${project ? project.getProjectName() : ""} WatchType: ${watchType}`;

}

function isScriptInfoWatchedFromNodeModules(info: ScriptInfo) {

return !info.isScriptOpen() && info.mTime !== undefined;

}

/*@internal*/

/** true if script info is part of project and is not in project because it is referenced from project reference source */

export function projectContainsInfoDirectly(project: Project, info: ScriptInfo) {

return project.containsScriptInfo(info) &&

!project.isSourceOfProjectReferenceRedirect(info.path);

}

/*@internal*/

export function updateProjectIfDirty(project: Project) {

project.invalidateResolutionsOfFailedLookupLocations();

return project.dirty && project.updateGraph();

}

function setProjectOptionsUsed(project: ConfiguredProject | ExternalProject) {

}

/*@internal*/

export interface OpenFileArguments {

}

/*@internal*/

export interface ChangeFileArguments {

fileName: string;

changes: Iterator<TextChange>;

}

export class ProjectService {