let acc = 5381;

for (let i = 0; i < data.length; i++) {

acc = ((acc << 5) + acc) + data.charCodeAt(i);

}

return acc.toString();

if ((Error as any).stackTraceLimit < 100) { // Also tests that we won't set the property if it doesn't exist.

(Error as any).stackTraceLimit = 100;

}

Created,

Changed,

Deleted

readonly fileName: string;

readonly callback: FileWatcherCallback;

mtime: Date;

High = 2000,

Medium = 500,

Low = 250

Low: number;

Medium: number;

High: number;

return {

[PollingInterval.Low]: levels.Low,

[PollingInterval.Medium]: levels.Medium,

[PollingInterval.High]: levels.High

};

if (!system.getEnvironmentVariable) {

return;

}

const pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval);

pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;

unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || unchangedPollThresholds;

function getLevel(envVar: string, level: keyof Levels) {

return system.getEnvironmentVariable(`${envVar}_${level.toUpperCase()}`);

}

function getCustomLevels(baseVariable: string) {

let customLevels: Partial<Levels> | undefined;

setCustomLevel("Low");

setCustomLevel("Medium");

setCustomLevel("High");

return customLevels;

function setCustomLevel(level: keyof Levels) {

const customLevel = getLevel(baseVariable, level);

if (customLevel) {

(customLevels || (customLevels = {}))[level] = Number(customLevel);

}

}

}

function setCustomLevels(baseVariable: string, levels: Levels) {

const customLevels = getCustomLevels(baseVariable);

if (customLevels) {

setLevel("Low");

setLevel("Medium");

setLevel("High");

return true;

}

return false;

function setLevel(level: keyof Levels) {

levels[level] = customLevels![level] || levels[level];

}

}

function getCustomPollingBasedLevels(baseVariable: string, defaultLevels: Levels) {

const customLevels = getCustomLevels(baseVariable);

return (pollingIntervalChanged || customLevels) &&

createPollingIntervalBasedLevels(customLevels ? { ...defaultLevels, ...customLevels } : defaultLevels);

}

host: { getModifiedTime: NonNullable<System["getModifiedTime"]>; },

queue: (T | undefined)[],

pollIndex: number, chunkSize: number,

callbackOnWatchFileStat?: (watchedFile: T, pollIndex: number, fileChanged: boolean) => void

) {

let definedValueCopyToIndex = pollIndex;

// Max visit would be all elements of the queue

for (let canVisit = queue.length; chunkSize && canVisit; nextPollIndex(), canVisit--) {

const watchedFile = queue[pollIndex];

if (!watchedFile) {

continue;

}

else if (watchedFile.isClosed) {

queue[pollIndex] = undefined;

continue;

}

// Only files polled count towards chunkSize

chunkSize--;

const fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(host, watchedFile.fileName));

if (watchedFile.isClosed) {

// Closed watcher as part of callback

queue[pollIndex] = undefined;

continue;

}

callbackOnWatchFileStat?.(watchedFile, pollIndex, fileChanged);

// Defragment the queue while we are at it

if (queue[pollIndex]) {

// Copy this file to the non hole location

if (definedValueCopyToIndex < pollIndex) {

queue[definedValueCopyToIndex] = watchedFile;

queue[pollIndex] = undefined;

}

definedValueCopyToIndex++;

}

}

// Return next poll index

return pollIndex;

function nextPollIndex() {

pollIndex++;

if (pollIndex === queue.length) {

if (definedValueCopyToIndex < pollIndex) {

// There are holes from definedValueCopyToIndex to end of queue, change queue size

queue.length = definedValueCopyToIndex;

}

pollIndex = 0;

definedValueCopyToIndex = 0;

}

}

getModifiedTime: NonNullable<System["getModifiedTime"]>;

setTimeout: NonNullable<System["setTimeout"]>;

}): HostWatchFile {

interface WatchedFile extends ts.WatchedFile {

isClosed?: boolean;

unchangedPolls: number;

}

interface PollingIntervalQueue extends Array<WatchedFile> {

pollingInterval: PollingInterval;

pollIndex: number;

pollScheduled: boolean;

}

const watchedFiles: WatchedFile[] = [];

const changedFilesInLastPoll: WatchedFile[] = [];

const lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low);

const mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium);

const highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High);

return watchFile;

function watchFile(fileName: string, callback: FileWatcherCallback, defaultPollingInterval: PollingInterval): FileWatcher {

const file: WatchedFile = {

fileName,

callback,

unchangedPolls: 0,

mtime: getModifiedTime(host, fileName)

};

watchedFiles.push(file);

addToPollingIntervalQueue(file, defaultPollingInterval);

return {

close: () => {

file.isClosed = true;

// Remove from watchedFiles

unorderedRemoveItem(watchedFiles, file);

// Do not update polling interval queue since that will happen as part of polling

}

};

}

function createPollingIntervalQueue(pollingInterval: PollingInterval): PollingIntervalQueue {

const queue = [] as WatchedFile[] as PollingIntervalQueue;

queue.pollingInterval = pollingInterval;

queue.pollIndex = 0;

queue.pollScheduled = false;

return queue;

}

function pollPollingIntervalQueue(queue: PollingIntervalQueue) {

queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]);

// Set the next polling index and timeout

if (queue.length) {

scheduleNextPoll(queue.pollingInterval);

}

else {

Debug.assert(queue.pollIndex === 0);

queue.pollScheduled = false;

}

}

function pollLowPollingIntervalQueue(queue: PollingIntervalQueue) {

// Always poll complete list of changedFilesInLastPoll

pollQueue(changedFilesInLastPoll, PollingInterval.Low, /*pollIndex*/ 0, changedFilesInLastPoll.length);

// Finally do the actual polling of the queue

pollPollingIntervalQueue(queue);

// Schedule poll if there are files in changedFilesInLastPoll but no files in the actual queue

// as pollPollingIntervalQueue wont schedule for next poll

if (!queue.pollScheduled && changedFilesInLastPoll.length) {

scheduleNextPoll(PollingInterval.Low);

}

}

function pollQueue(queue: (WatchedFile | undefined)[], pollingInterval: PollingInterval, pollIndex: number, chunkSize: number) {

return pollWatchedFileQueue(

host,

queue,

pollIndex,

chunkSize,

onWatchFileStat

);

function onWatchFileStat(watchedFile: WatchedFile, pollIndex: number, fileChanged: boolean) {

if (fileChanged) {

watchedFile.unchangedPolls = 0;

// Changed files go to changedFilesInLastPoll queue

if (queue !== changedFilesInLastPoll) {

queue[pollIndex] = undefined;

addChangedFileToLowPollingIntervalQueue(watchedFile);

}

}

else if (watchedFile.unchangedPolls !== unchangedPollThresholds[pollingInterval]) {

watchedFile.unchangedPolls++;

}

else if (queue === changedFilesInLastPoll) {

// Restart unchangedPollCount for unchanged file and move to low polling interval queue

watchedFile.unchangedPolls = 1;

queue[pollIndex] = undefined;

addToPollingIntervalQueue(watchedFile, PollingInterval.Low);

}

else if (pollingInterval !== PollingInterval.High) {

watchedFile.unchangedPolls++;

queue[pollIndex] = undefined;

addToPollingIntervalQueue(watchedFile, pollingInterval === PollingInterval.Low ? PollingInterval.Medium : PollingInterval.High);

}

}

}

function pollingIntervalQueue(pollingInterval: PollingInterval) {

switch (pollingInterval) {

case PollingInterval.Low:

return lowPollingIntervalQueue;

case PollingInterval.Medium:

return mediumPollingIntervalQueue;

case PollingInterval.High:

return highPollingIntervalQueue;

}

}

function addToPollingIntervalQueue(file: WatchedFile, pollingInterval: PollingInterval) {

pollingIntervalQueue(pollingInterval).push(file);

scheduleNextPollIfNotAlreadyScheduled(pollingInterval);

}

function addChangedFileToLowPollingIntervalQueue(file: WatchedFile) {

changedFilesInLastPoll.push(file);

scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low);

}

function scheduleNextPollIfNotAlreadyScheduled(pollingInterval: PollingInterval) {

if (!pollingIntervalQueue(pollingInterval).pollScheduled) {

scheduleNextPoll(pollingInterval);

}

}

function scheduleNextPoll(pollingInterval: PollingInterval) {

pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval));

}

// One file can have multiple watchers

const fileWatcherCallbacks = createMultiMap<FileWatcherCallback>();

const dirWatchers = new Map<string, DirectoryWatcher>();

const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames);

return nonPollingWatchFile;

function nonPollingWatchFile(fileName: string, callback: FileWatcherCallback, _pollingInterval: PollingInterval, fallbackOptions: WatchOptions | undefined): FileWatcher {

const filePath = toCanonicalName(fileName);

fileWatcherCallbacks.add(filePath, callback);

const dirPath = getDirectoryPath(filePath) || ".";

const watcher = dirWatchers.get(dirPath) ||

createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);

watcher.referenceCount++;

return {

close: () => {

if (watcher.referenceCount === 1) {

watcher.close();

dirWatchers.delete(dirPath);

}

else {

watcher.referenceCount--;

}

fileWatcherCallbacks.remove(filePath, callback);

}

};

}

function createDirectoryWatcher(dirName: string, dirPath: string, fallbackOptions: WatchOptions | undefined) {

const watcher = fsWatch(

dirName,

FileSystemEntryKind.Directory,

(_eventName: string, relativeFileName) => {

// When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined"

if (!isString(relativeFileName)) return;

const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);

// Some applications save a working file via rename operations

const callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));

if (callbacks) {

for (const fileCallback of callbacks) {

fileCallback(fileName, FileWatcherEventKind.Changed);

}

}

},

/*recursive*/ false,

PollingInterval.Medium,

fallbackOptions

) as DirectoryWatcher;

watcher.referenceCount = 0;

dirWatchers.set(dirPath, watcher);

return watcher;

}

getModifiedTime: NonNullable<System["getModifiedTime"]>;

setTimeout: NonNullable<System["setTimeout"]>;

}): HostWatchFile {

const watchedFiles: (WatchedFileWithIsClosed | undefined)[] = [];

let pollIndex = 0;

let pollScheduled: any;

return watchFile;

function watchFile(fileName: string, callback: FileWatcherCallback): FileWatcher {

const file: WatchedFileWithIsClosed = {

fileName,

callback,

mtime: getModifiedTime(host, fileName)

};

watchedFiles.push(file);

scheduleNextPoll();

return {

close: () => {

file.isClosed = true;

unorderedRemoveItem(watchedFiles, file);

}

};

}

function pollQueue() {

pollScheduled = undefined;

pollIndex = pollWatchedFileQueue(host, watchedFiles, pollIndex, pollingChunkSize[PollingInterval.Low]);

scheduleNextPoll();

}

function scheduleNextPoll() {

if (!watchedFiles.length || pollScheduled) return;

pollScheduled = host.setTimeout(pollQueue, PollingInterval.High);

}

watchFile: HostWatchFile,

useCaseSensitiveFileNames: boolean

): HostWatchFile {

interface SingleFileWatcher {

watcher: FileWatcher;

refCount: number;

}

const cache = new Map<string, SingleFileWatcher>();

const callbacksCache = createMultiMap<FileWatcherCallback>();

const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);

return (fileName, callback, pollingInterval, options) => {

const path = toCanonicalFileName(fileName);

const existing = cache.get(path);

if (existing) {

existing.refCount++;

}

else {

cache.set(path, {

watcher: watchFile(

fileName,

(fileName, eventKind) => forEach(

callbacksCache.get(path),

cb => cb(fileName, eventKind)

),

pollingInterval,

options

),

refCount: 1

});

}

callbacksCache.add(path, callback);

return {

close: () => {

const watcher = Debug.checkDefined(cache.get(path));

callbacksCache.remove(path, callback);

watcher.refCount--;

if (watcher.refCount) return;

cache.delete(path);

closeFileWatcherOf(watcher);

}

};

};

const oldTime = watchedFile.mtime.getTime();

const newTime = modifiedTime.getTime();

if (oldTime !== newTime) {

watchedFile.mtime = modifiedTime;

watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime));

return true;

}

return false;

return oldTime === 0

? FileWatcherEventKind.Created

: newTime === 0

? FileWatcherEventKind.Deleted

: FileWatcherEventKind.Changed;

watchDirectory: HostWatchDirectory;

useCaseSensitiveFileNames: boolean;

getCurrentDirectory: System["getCurrentDirectory"];

getAccessibleSortedChildDirectories(path: string): readonly string[];

directoryExists(dir: string): boolean;

realpath(s: string): string;

setTimeout: NonNullable<System["setTimeout"]>;

clearTimeout: NonNullable<System["clearTimeout"]>;

watchDirectory,

useCaseSensitiveFileNames,

getCurrentDirectory,

getAccessibleSortedChildDirectories,

directoryExists,

realpath,

setTimeout,

clearTimeout

}: RecursiveDirectoryWatcherHost): HostWatchDirectory {

interface ChildDirectoryWatcher extends FileWatcher {

dirName: string;

}

type ChildWatches = readonly ChildDirectoryWatcher[];

interface HostDirectoryWatcher {

watcher: FileWatcher;

childWatches: ChildWatches;

refCount: number;

}

const cache = new Map<string, HostDirectoryWatcher>();

const callbackCache = createMultiMap<Path, { dirName: string; callback: DirectoryWatcherCallback; }>();

const cacheToUpdateChildWatches = new Map<Path, { dirName: string; options: WatchOptions | undefined; fileNames: string[]; }>();

let timerToUpdateChildWatches: any;

const filePathComparer = getStringComparer(!useCaseSensitiveFileNames);

const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames);

return (dirName, callback, recursive, options) => recursive ?

createDirectoryWatcher(dirName, options, callback) :

watchDirectory(dirName, callback, recursive, options);

/**

function createDirectoryWatcher(dirName: string, options: WatchOptions | undefined, callback?: DirectoryWatcherCallback): ChildDirectoryWatcher {

const dirPath = toCanonicalFilePath(dirName) as Path;

let directoryWatcher = cache.get(dirPath);

if (directoryWatcher) {

directoryWatcher.refCount++;

}

else {

directoryWatcher = {

watcher: watchDirectory(dirName, fileName => {

if (isIgnoredPath(fileName, options)) return;

if (options?.synchronousWatchDirectory) {

// Call the actual callback

invokeCallbacks(dirPath, fileName);

// Iterate through existing children and update the watches if needed

updateChildWatches(dirName, dirPath, options);

}

else {

nonSyncUpdateChildWatches(dirName, dirPath, fileName, options);

}

}, /*recursive*/ false, options),

refCount: 1,

childWatches: emptyArray

};

cache.set(dirPath, directoryWatcher);

updateChildWatches(dirName, dirPath, options);

}

const callbackToAdd = callback && { dirName, callback };

if (callbackToAdd) {

callbackCache.add(dirPath, callbackToAdd);

}

return {

dirName,

close: () => {

const directoryWatcher = Debug.checkDefined(cache.get(dirPath));

if (callbackToAdd) callbackCache.remove(dirPath, callbackToAdd);

directoryWatcher.refCount--;

if (directoryWatcher.refCount) return;

cache.delete(dirPath);

closeFileWatcherOf(directoryWatcher);

directoryWatcher.childWatches.forEach(closeFileWatcher);

}

};

}

type InvokeMap = ESMap<Path, string[] | true>;

function invokeCallbacks(dirPath: Path, fileName: string): void;

function invokeCallbacks(dirPath: Path, invokeMap: InvokeMap, fileNames: string[] | undefined): void;

function invokeCallbacks(dirPath: Path, fileNameOrInvokeMap: string | InvokeMap, fileNames?: string[]) {

let fileName: string | undefined;

let invokeMap: InvokeMap | undefined;

if (isString(fileNameOrInvokeMap)) {

fileName = fileNameOrInvokeMap;

}

else {

invokeMap = fileNameOrInvokeMap;

}

// Call the actual callback

callbackCache.forEach((callbacks, rootDirName) => {

if (invokeMap && invokeMap.get(rootDirName) === true) return;

if (rootDirName === dirPath || (startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === directorySeparator)) {

if (invokeMap) {

if (fileNames) {

const existing = invokeMap.get(rootDirName);

if (existing) {

(existing as string[]).push(...fileNames);

}

else {

invokeMap.set(rootDirName, fileNames.slice());

}

}

else {

invokeMap.set(rootDirName, true);

}

}

else {

callbacks.forEach(({ callback }) => callback(fileName!));

}

}

});

}

function nonSyncUpdateChildWatches(dirName: string, dirPath: Path, fileName: string, options: WatchOptions | undefined) {

// Iterate through existing children and update the watches if needed

const parentWatcher = cache.get(dirPath);

if (parentWatcher && directoryExists(dirName)) {

// Schedule the update and postpone invoke for callbacks

scheduleUpdateChildWatches(dirName, dirPath, fileName, options);

return;

}

// Call the actual callbacks and remove child watches

invokeCallbacks(dirPath, fileName);

removeChildWatches(parentWatcher);

}

function scheduleUpdateChildWatches(dirName: string, dirPath: Path, fileName: string, options: WatchOptions | undefined) {

const existing = cacheToUpdateChildWatches.get(dirPath);

if (existing) {

existing.fileNames.push(fileName);

}

else {

cacheToUpdateChildWatches.set(dirPath, { dirName, options, fileNames: [fileName] });

}

if (timerToUpdateChildWatches) {

clearTimeout(timerToUpdateChildWatches);

timerToUpdateChildWatches = undefined;

}

timerToUpdateChildWatches = setTimeout(onTimerToUpdateChildWatches, 1000);

}

function onTimerToUpdateChildWatches() {

timerToUpdateChildWatches = undefined;

sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);

const start = timestamp();

const invokeMap = new Map<Path, string[]>();

while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {

const result = cacheToUpdateChildWatches.entries().next();

Debug.assert(!result.done);

const { value: [dirPath, { dirName, options, fileNames }] } = result;

cacheToUpdateChildWatches.delete(dirPath);

// Because the child refresh is fresh, we would need to invalidate whole root directory being watched

// to ensure that all the changes are reflected at this time

const hasChanges = updateChildWatches(dirName, dirPath, options);

invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames);

}

sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start}ms:: ${cacheToUpdateChildWatches.size}`);

callbackCache.forEach((callbacks, rootDirName) => {

const existing = invokeMap.get(rootDirName);

if (existing) {

callbacks.forEach(({ callback, dirName }) => {

if (isArray(existing)) {

existing.forEach(callback);

}

else {

callback(dirName);

}

});

}

});

const elapsed = timestamp() - start;

sysLog(`sysLog:: Elapsed:: ${elapsed}ms:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size} ${timerToUpdateChildWatches}`);

}

function removeChildWatches(parentWatcher: HostDirectoryWatcher | undefined) {

if (!parentWatcher) return;

const existingChildWatches = parentWatcher.childWatches;

parentWatcher.childWatches = emptyArray;

for (const childWatcher of existingChildWatches) {

childWatcher.close();

removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));

}

}

function updateChildWatches(parentDir: string, parentDirPath: Path, options: WatchOptions | undefined) {

// Iterate through existing children and update the watches if needed

const parentWatcher = cache.get(parentDirPath);

if (!parentWatcher) return false;

let newChildWatches: ChildDirectoryWatcher[] | undefined;

const hasChanges = enumerateInsertsAndDeletes<string, ChildDirectoryWatcher>(

directoryExists(parentDir) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), child => {

const childFullName = getNormalizedAbsolutePath(child, parentDir);

// Filter our the symbolic link directories since those arent included in recursive watch

// which is same behaviour when recursive: true is passed to fs.watch

return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === Comparison.EqualTo ? childFullName : undefined;

}) : emptyArray,

parentWatcher.childWatches,

(child, childWatcher) => filePathComparer(child, childWatcher.dirName),

createAndAddChildDirectoryWatcher,

closeFileWatcher,

addChildDirectoryWatcher

);

parentWatcher.childWatches = newChildWatches || emptyArray;

return hasChanges;

/**

function createAndAddChildDirectoryWatcher(childName: string) {

const result = createDirectoryWatcher(childName, options);

addChildDirectoryWatcher(result);

}

/**

function addChildDirectoryWatcher(childWatcher: ChildDirectoryWatcher) {

(newChildWatches || (newChildWatches = [])).push(childWatcher);

}

}

function isIgnoredPath(path: string, options: WatchOptions | undefined) {

return some(ignoredPaths, searchPath => isInPath(path, searchPath)) ||

isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory);

}

function isInPath(path: string, searchPath: string) {

if (stringContains(path, searchPath)) return true;

if (useCaseSensitiveFileNames) return false;

return stringContains(toCanonicalFilePath(path), searchPath);

}

fileName: string,

callback: FileWatcherCallback,

fileExists: System["fileExists"]

): FsWatchCallback {

return eventName => {

if (eventName === "rename") {

callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);

}

else {

// Change

callback(fileName, FileWatcherEventKind.Changed);

}

};

pathToCheck: string,

options: WatchOptions | undefined,

useCaseSensitiveFileNames: boolean,

getCurrentDirectory: System["getCurrentDirectory"],

) {

return (options?.excludeDirectories || options?.excludeFiles) && (