/*! *****************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use

this file except in compliance with the License. You may obtain a copy of the

License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions

and limitations under the License.

***************************************************************************** */

var __extends = (this && this.__extends) || function (d, b) {

for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];

function __() { this.constructor = d; }

d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

};

var ts;

(function (ts) {

var OperationCanceledException = (function () {

function OperationCanceledException() {

}

return OperationCanceledException;

}());

ts.OperationCanceledException = OperationCanceledException;

(function (ExitStatus) {

ExitStatus[ExitStatus["Success"] = 0] = "Success";

ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped";

ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated";

})(ts.ExitStatus || (ts.ExitStatus = {}));

var ExitStatus = ts.ExitStatus;

(function (TypeReferenceSerializationKind) {

TypeReferenceSerializationKind[TypeReferenceSerializationKind["Unknown"] = 0] = "Unknown";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["VoidNullableOrNeverType"] = 2] = "VoidNullableOrNeverType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["NumberLikeType"] = 3] = "NumberLikeType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 4] = "StringLikeType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 5] = "BooleanType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 6] = "ArrayLikeType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 7] = "ESSymbolType";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["Promise"] = 8] = "Promise";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 9] = "TypeWithCallSignature";

TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 10] = "ObjectType";

})(ts.TypeReferenceSerializationKind || (ts.TypeReferenceSerializationKind = {}));

var TypeReferenceSerializationKind = ts.TypeReferenceSerializationKind;

(function (DiagnosticCategory) {

DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning";

DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";

DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message";

})(ts.DiagnosticCategory || (ts.DiagnosticCategory = {}));

var DiagnosticCategory = ts.DiagnosticCategory;

(function (ModuleResolutionKind) {

ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";

ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";

})(ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));

var ModuleResolutionKind = ts.ModuleResolutionKind;

(function (ModuleKind) {

ModuleKind[ModuleKind["None"] = 0] = "None";

ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS";

ModuleKind[ModuleKind["AMD"] = 2] = "AMD";

ModuleKind[ModuleKind["UMD"] = 3] = "UMD";

ModuleKind[ModuleKind["System"] = 4] = "System";

ModuleKind[ModuleKind["ES6"] = 5] = "ES6";

ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";

})(ts.ModuleKind || (ts.ModuleKind = {}));

var ModuleKind = ts.ModuleKind;

})(ts || (ts = {}));

var ts;

(function (ts) {

ts.timestamp = typeof performance !== "undefined" && performance.now ? function () { return performance.now(); } : Date.now ? Date.now : function () { return +(new Date()); };

})(ts || (ts = {}));

var ts;

(function (ts) {

var performance;

(function (performance) {

var profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true

? onProfilerEvent

: function (markName) { };

var enabled = false;

var profilerStart = 0;

var counts;

var marks;

var measures;

function mark(markName) {

if (enabled) {

marks[markName] = ts.timestamp();

counts[markName] = (counts[markName] || 0) + 1;

profilerEvent(markName);

}

}

performance.mark = mark;

function measure(measureName, startMarkName, endMarkName) {

if (enabled) {

var end = endMarkName && marks[endMarkName] || ts.timestamp();

var start = startMarkName && marks[startMarkName] || profilerStart;

measures[measureName] = (measures[measureName] || 0) + (end - start);

}

}

performance.measure = measure;

function getCount(markName) {

return counts && counts[markName] || 0;

}

performance.getCount = getCount;

function getDuration(measureName) {

return measures && measures[measureName] || 0;

}

performance.getDuration = getDuration;

function forEachMeasure(cb) {

for (var key in measures) {

cb(key, measures[key]);

}

}

performance.forEachMeasure = forEachMeasure;

function enable() {

counts = ts.createMap();

marks = ts.createMap();

measures = ts.createMap();

enabled = true;

profilerStart = ts.timestamp();

}

performance.enable = enable;

function disable() {

enabled = false;

}

performance.disable = disable;

})(performance = ts.performance || (ts.performance = {}));

})(ts || (ts = {}));

var ts;

(function (ts) {

var createObject = Object.create;

function createMap(template) {

var map = createObject(null);

map["__"] = undefined;

delete map["__"];

for (var key in template)

if (hasOwnProperty.call(template, key)) {

map[key] = template[key];

}

return map;

}

ts.createMap = createMap;

function createFileMap(keyMapper) {

var files = createMap();

return {

get: get,

set: set,

contains: contains,

remove: remove,

forEachValue: forEachValueInMap,

getKeys: getKeys,

clear: clear

};

function forEachValueInMap(f) {

for (var key in files) {

f(key, files[key]);

}

}

function getKeys() {

var keys = [];

for (var key in files) {

keys.push(key);

}

return keys;

}

function get(path) {

return files[toKey(path)];

}

function set(path, value) {

files[toKey(path)] = value;

}

function contains(path) {

return toKey(path) in files;

}

function remove(path) {

var key = toKey(path);

delete files[key];

}

function clear() {

files = createMap();

}

function toKey(path) {

return keyMapper ? keyMapper(path) : path;

}

}

ts.createFileMap = createFileMap;

function toPath(fileName, basePath, getCanonicalFileName) {

var nonCanonicalizedPath = isRootedDiskPath(fileName)

? normalizePath(fileName)

: getNormalizedAbsolutePath(fileName, basePath);

return getCanonicalFileName(nonCanonicalizedPath);

}

ts.toPath = toPath;

function forEach(array, callback) {

if (array) {

for (var i = 0, len = array.length; i < len; i++) {

var result = callback(array[i], i);

if (result) {

return result;

}

}

}

return undefined;

}

ts.forEach = forEach;

function every(array, callback) {

if (array) {

for (var i = 0, len = array.length; i < len; i++) {

if (!callback(array[i], i)) {

return false;

}

}

}

return true;

}

ts.every = every;

function find(array, predicate) {

for (var i = 0, len = array.length; i < len; i++) {

var value = array[i];

if (predicate(value, i)) {

return value;

}

}

return undefined;

}

ts.find = find;

function findMap(array, callback) {

for (var i = 0, len = array.length; i < len; i++) {

var result = callback(array[i], i);

if (result) {

return result;

}

}

Debug.fail();

}

ts.findMap = findMap;

function contains(array, value) {

if (array) {

for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {

var v = array_1[_i];

if (v === value) {

return true;

}

}

}

return false;

}

ts.contains = contains;

function indexOf(array, value) {

if (array) {

for (var i = 0, len = array.length; i < len; i++) {

if (array[i] === value) {

return i;

}

}

}

return -1;

}

ts.indexOf = indexOf;

function indexOfAnyCharCode(text, charCodes, start) {

for (var i = start || 0, len = text.length; i < len; i++) {

if (contains(charCodes, text.charCodeAt(i))) {

return i;

}

}

return -1;

}

ts.indexOfAnyCharCode = indexOfAnyCharCode;

function countWhere(array, predicate) {

var count = 0;

if (array) {

for (var i = 0; i < array.length; i++) {

var v = array[i];

if (predicate(v, i)) {

count++;

}

}

}

return count;

}

ts.countWhere = countWhere;

function filter(array, f) {

if (array) {

var len = array.length;

var i = 0;

while (i < len && f(array[i]))

i++;

if (i < len) {

var result = array.slice(0, i);

i++;

while (i < len) {

var item = array[i];

if (f(item)) {

result.push(item);

}

i++;

}

return result;

}

}

return array;

}

ts.filter = filter;

function removeWhere(array, f) {

var outIndex = 0;

for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {

var item = array_2[_i];

if (!f(item)) {

array[outIndex] = item;

outIndex++;

}

}

if (outIndex !== array.length) {

array.length = outIndex;

return true;

}

return false;

}

ts.removeWhere = removeWhere;

function filterMutate(array, f) {

var outIndex = 0;

for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {

var item = array_3[_i];

if (f(item)) {

array[outIndex] = item;

outIndex++;

}

}

array.length = outIndex;

}

ts.filterMutate = filterMutate;

function map(array, f) {

var result;

if (array) {

result = [];

for (var i = 0; i < array.length; i++) {

var v = array[i];

result.push(f(v, i));

}

}

return result;

}

ts.map = map;

function flatten(array) {

var result;

if (array) {

result = [];

for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {

var v = array_4[_i];

if (v) {

if (isArray(v)) {

addRange(result, v);

}

else {

result.push(v);

}

}

}

}

return result;

}

ts.flatten = flatten;

function flatMap(array, mapfn) {

var result;

if (array) {

result = [];

for (var i = 0; i < array.length; i++) {

var v = mapfn(array[i], i);

if (v) {

if (isArray(v)) {

addRange(result, v);

}

else {

result.push(v);

}

}

}

}

return result;

}

ts.flatMap = flatMap;

function span(array, f) {

if (array) {

for (var i = 0; i < array.length; i++) {

if (!f(array[i], i)) {

return [array.slice(0, i), array.slice(i)];

}

}

return [array.slice(0), []];

}

return undefined;

}

ts.span = span;

function spanMap(array, keyfn, mapfn) {

var result;

if (array) {

result = [];

var len = array.length;

var previousKey = void 0;

var key = void 0;

var start = 0;

var pos = 0;

while (start < len) {

while (pos < len) {

var value = array[pos];

key = keyfn(value, pos);

if (pos === 0) {

previousKey = key;

}

else if (key !== previousKey) {

break;

}

pos++;

}

if (start < pos) {

var v = mapfn(array.slice(start, pos), previousKey, start, pos);

if (v) {

result.push(v);

}

start = pos;

}

previousKey = key;

pos++;

}

}

return result;

}

ts.spanMap = spanMap;

function mapObject(object, f) {

var result;

if (object) {

result = {};

for (var _i = 0, _a = getOwnKeys(object); _i < _a.length; _i++) {

var v = _a[_i];

var _b = f(v, object[v]) || [undefined, undefined], key = _b[0], value = _b[1];

if (key !== undefined) {

result[key] = value;

}

}

}

return result;

}

ts.mapObject = mapObject;

function concatenate(array1, array2) {

if (!array2 || !array2.length)

return array1;

if (!array1 || !array1.length)

return array2;

return array1.concat(array2);

}

ts.concatenate = concatenate;

function deduplicate(array, areEqual) {

var result;

if (array) {

result = [];

loop: for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {

var item = array_5[_i];

for (var _a = 0, result_1 = result; _a < result_1.length; _a++) {

var res = result_1[_a];

if (areEqual ? areEqual(res, item) : res === item) {

continue loop;

}

}

result.push(item);

}

}

return result;

}

ts.deduplicate = deduplicate;

function compact(array) {

var result;

if (array) {

for (var i = 0; i < array.length; i++) {

var v = array[i];

if (result || !v) {

if (!result) {

result = array.slice(0, i);

}

if (v) {

result.push(v);

}

}

}

}

return result || array;

}

ts.compact = compact;

function sum(array, prop) {

var result = 0;

for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {

var v = array_6[_i];

result += v[prop];

}

return result;

}

ts.sum = sum;

function addRange(to, from) {

if (to && from) {

for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {

var v = from_1[_i];

if (v !== undefined) {

to.push(v);

}

}

}

}

ts.addRange = addRange;

function rangeEquals(array1, array2, pos, end) {

while (pos < end) {

if (array1[pos] !== array2[pos]) {

return false;

}

pos++;

}

return true;

}

ts.rangeEquals = rangeEquals;

function firstOrUndefined(array) {

return array && array.length > 0

? array[0]

: undefined;

}

ts.firstOrUndefined = firstOrUndefined;

function singleOrUndefined(array) {

return array && array.length === 1

? array[0]

: undefined;

}

ts.singleOrUndefined = singleOrUndefined;

function singleOrMany(array) {

return array && array.length === 1

? array[0]

: array;

}

ts.singleOrMany = singleOrMany;

function lastOrUndefined(array) {

return array && array.length > 0

? array[array.length - 1]

: undefined;

}

ts.lastOrUndefined = lastOrUndefined;

function binarySearch(array, value, comparer) {

if (!array || array.length === 0) {

return -1;

}

var low = 0;

var high = array.length - 1;

comparer = comparer !== undefined

? comparer

: function (v1, v2) { return (v1 < v2 ? -1 : (v1 > v2 ? 1 : 0)); };

while (low <= high) {

var middle = low + ((high - low) >> 1);

var midValue = array[middle];

if (comparer(midValue, value) === 0) {

return middle;

}

else if (comparer(midValue, value) > 0) {

high = middle - 1;

}

else {

low = middle + 1;

}

}

return ~low;

}

ts.binarySearch = binarySearch;

function reduceLeft(array, f, initial, start, count) {

if (array && array.length > 0) {

var size = array.length;

if (size > 0) {

var pos = start === undefined || start < 0 ? 0 : start;

var end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count;

var result = void 0;

if (arguments.length <= 2) {

result = array[pos];

pos++;

}

else {

result = initial;

}

while (pos <= end) {

result = f(result, array[pos], pos);

pos++;

}

return result;

}

}

return initial;

}

ts.reduceLeft = reduceLeft;

function reduceRight(array, f, initial, start, count) {

if (array) {

var size = array.length;

if (size > 0) {

var pos = start === undefined || start > size - 1 ? size - 1 : start;

var end = count === undefined || pos - count < 0 ? 0 : pos - count;

var result = void 0;

if (arguments.length <= 2) {

result = array[pos];

pos--;

}

else {

result = initial;

}

while (pos >= end) {

result = f(result, array[pos], pos);

pos--;

}

return result;

}

}

return initial;

}

ts.reduceRight = reduceRight;

var hasOwnProperty = Object.prototype.hasOwnProperty;

function hasProperty(map, key) {

return hasOwnProperty.call(map, key);

}

ts.hasProperty = hasProperty;

function getProperty(map, key) {

return hasOwnProperty.call(map, key) ? map[key] : undefined;

}

ts.getProperty = getProperty;

function getOwnKeys(map) {

var keys = [];

for (var key in map)

if (hasOwnProperty.call(map, key)) {

keys.push(key);

}

return keys;

}

ts.getOwnKeys = getOwnKeys;

function forEachProperty(map, callback) {

var result;

for (var key in map) {

if (result = callback(map[key], key))

break;

}

return result;

}

ts.forEachProperty = forEachProperty;

function someProperties(map, predicate) {

for (var key in map) {

if (!predicate || predicate(map[key], key))

return true;

}

return false;

}

ts.someProperties = someProperties;

function copyProperties(source, target) {

for (var key in source) {

target[key] = source[key];

}

}

ts.copyProperties = copyProperties;

function assign(t) {

var args = [];

for (var _i = 1; _i < arguments.length; _i++) {

args[_i - 1] = arguments[_i];

}

for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {

var arg = args_1[_a];

for (var _b = 0, _c = getOwnKeys(arg); _b < _c.length; _b++) {

var p = _c[_b];

t[p] = arg[p];

}

}

return t;

}

ts.assign = assign;

function reduceProperties(map, callback, initial) {

var result = initial;

for (var key in map) {

result = callback(result, map[key], String(key));

}

return result;

}

ts.reduceProperties = reduceProperties;

function reduceOwnProperties(map, callback, initial) {

var result = initial;

for (var key in map)

if (hasOwnProperty.call(map, key)) {

result = callback(result, map[key], String(key));

}

return result;

}

ts.reduceOwnProperties = reduceOwnProperties;

function equalOwnProperties(left, right, equalityComparer) {

if (left === right)

return true;

if (!left || !right)

return false;

for (var key in left)

if (hasOwnProperty.call(left, key)) {

if (!hasOwnProperty.call(right, key) === undefined)

return false;

if (equalityComparer ? !equalityComparer(left[key], right[key]) : left[key] !== right[key])

return false;

}

for (var key in right)

if (hasOwnProperty.call(right, key)) {

if (!hasOwnProperty.call(left, key))

return false;

}

return true;

}

ts.equalOwnProperties = equalOwnProperties;

function arrayToMap(array, makeKey, makeValue) {

var result = createMap();

for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {

var value = array_7[_i];

result[makeKey(value)] = makeValue ? makeValue(value) : value;

}

return result;

}

ts.arrayToMap = arrayToMap;

function isEmpty(map) {

for (var id in map) {

if (hasProperty(map, id)) {

return false;

}

}

return true;

}

ts.isEmpty = isEmpty;

function cloneMap(map) {

var clone = createMap();

copyProperties(map, clone);

return clone;

}

ts.cloneMap = cloneMap;

function clone(object) {

var result = {};

for (var id in object) {

if (hasOwnProperty.call(object, id)) {

result[id] = object[id];

}

}

return result;

}

ts.clone = clone;

function extend(first, second) {

var result = {};

for (var id in second)

if (hasOwnProperty.call(second, id)) {

result[id] = second[id];

}

for (var id in first)

if (hasOwnProperty.call(first, id)) {

result[id] = first[id];

}

return result;

}

ts.extend = extend;

function multiMapAdd(map, key, value) {

var values = map[key];

if (values) {

values.push(value);

return values;

}

else {

return map[key] = [value];

}

}

ts.multiMapAdd = multiMapAdd;

function multiMapRemove(map, key, value) {

var values = map[key];

if (values) {

unorderedRemoveItem(values, value);

if (!values.length) {

delete map[key];

}

}

}

ts.multiMapRemove = multiMapRemove;

function isArray(value) {

return Array.isArray ? Array.isArray(value) : value instanceof Array;

}

ts.isArray = isArray;

function memoize(callback) {

var value;

return function () {

if (callback) {

value = callback();

callback = undefined;

}

return value;

};

}

ts.memoize = memoize;

function formatStringFromArgs(text, args, baseIndex) {

baseIndex = baseIndex || 0;

return text.replace(/{(\d+)}/g, function (match, index) { return args[+index + baseIndex]; });

}

ts.localizedDiagnosticMessages = undefined;

function getLocaleSpecificMessage(message) {

return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message.key] || message.message;

}

ts.getLocaleSpecificMessage = getLocaleSpecificMessage;

function createFileDiagnostic(file, start, length, message) {

var end = start + length;

Debug.assert(start >= 0, "start must be non-negative, is " + start);

Debug.assert(length >= 0, "length must be non-negative, is " + length);

if (file) {

Debug.assert(start <= file.text.length, "start must be within the bounds of the file. " + start + " > " + file.text.length);

Debug.assert(end <= file.text.length, "end must be the bounds of the file. " + end + " > " + file.text.length);

}

var text = getLocaleSpecificMessage(message);

if (arguments.length > 4) {

text = formatStringFromArgs(text, arguments, 4);

}

return {

file: file,

start: start,

length: length,

messageText: text,

category: message.category,

code: message.code

};

}

ts.createFileDiagnostic = createFileDiagnostic;

function formatMessage(dummy, message) {

var text = getLocaleSpecificMessage(message);

if (arguments.length > 2) {

text = formatStringFromArgs(text, arguments, 2);

}

return text;

}

ts.formatMessage = formatMessage;

function createCompilerDiagnostic(message) {

var text = getLocaleSpecificMessage(message);

if (arguments.length > 1) {

text = formatStringFromArgs(text, arguments, 1);

}

return {

file: undefined,

start: undefined,

length: undefined,

messageText: text,

category: message.category,

code: message.code

};

}

ts.createCompilerDiagnostic = createCompilerDiagnostic;

function chainDiagnosticMessages(details, message) {

var text = getLocaleSpecificMessage(message);

if (arguments.length > 2) {

text = formatStringFromArgs(text, arguments, 2);

}

return {

messageText: text,

category: message.category,

code: message.code,

next: details

};

}

ts.chainDiagnosticMessages = chainDiagnosticMessages;

function concatenateDiagnosticMessageChains(headChain, tailChain) {

var lastChain = headChain;

while (lastChain.next) {

lastChain = lastChain.next;

}

lastChain.next = tailChain;

return headChain;

}

ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains;

function compareValues(a, b) {

if (a === b)

return 0;

if (a === undefined)

return -1;

if (b === undefined)

return 1;

return a < b ? -1 : 1;

}

ts.compareValues = compareValues;

function compareStrings(a, b, ignoreCase) {

if (a === b)

return 0;

if (a === undefined)

return -1;

if (b === undefined)

return 1;

if (ignoreCase) {

if (String.prototype.localeCompare) {

var result = a.localeCompare(b, undefined, { usage: "sort", sensitivity: "accent" });

return result < 0 ? -1 : result > 0 ? 1 : 0;

}

a = a.toUpperCase();

b = b.toUpperCase();

if (a === b)

return 0;

}

return a < b ? -1 : 1;

}

ts.compareStrings = compareStrings;

function compareStringsCaseInsensitive(a, b) {

return compareStrings(a, b, true);

}

ts.compareStringsCaseInsensitive = compareStringsCaseInsensitive;

function getDiagnosticFileName(diagnostic) {

return diagnostic.file ? diagnostic.file.fileName : undefined;

}

function compareDiagnostics(d1, d2) {

return compareValues(getDiagnosticFileName(d1), getDiagnosticFileName(d2)) ||

compareValues(d1.start, d2.start) ||

compareValues(d1.length, d2.length) ||

compareValues(d1.code, d2.code) ||

compareMessageText(d1.messageText, d2.messageText) ||

0;

}

ts.compareDiagnostics = compareDiagnostics;

function compareMessageText(text1, text2) {

while (text1 && text2) {

var string1 = typeof text1 === "string" ? text1 : text1.messageText;

var string2 = typeof text2 === "string" ? text2 : text2.messageText;

var res = compareValues(string1, string2);

if (res) {

return res;

}

text1 = typeof text1 === "string" ? undefined : text1.next;

text2 = typeof text2 === "string" ? undefined : text2.next;

}

if (!text1 && !text2) {

return 0;

}

return text1 ? 1 : -1;

}

function sortAndDeduplicateDiagnostics(diagnostics) {

return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics));

}

ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics;

function deduplicateSortedDiagnostics(diagnostics) {

if (diagnostics.length < 2) {

return diagnostics;

}

var newDiagnostics = [diagnostics[0]];

var previousDiagnostic = diagnostics[0];

for (var i = 1; i < diagnostics.length; i++) {

var currentDiagnostic = diagnostics[i];

var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0;

if (!isDupe) {

newDiagnostics.push(currentDiagnostic);

previousDiagnostic = currentDiagnostic;

}

}

return newDiagnostics;

}

ts.deduplicateSortedDiagnostics = deduplicateSortedDiagnostics;

function normalizeSlashes(path) {

return path.replace(/\\/g, "/");

}

ts.normalizeSlashes = normalizeSlashes;

function getRootLength(path) {

if (path.charCodeAt(0) === 47) {

if (path.charCodeAt(1) !== 47)

return 1;

var p1 = path.indexOf("/", 2);

if (p1 < 0)

return 2;

var p2 = path.indexOf("/", p1 + 1);

if (p2 < 0)

return p1 + 1;

return p2 + 1;

}

if (path.charCodeAt(1) === 58) {

if (path.charCodeAt(2) === 47)

return 3;

return 2;

}

if (path.lastIndexOf("file:///", 0) === 0) {

return "file:///".length;

}

var idx = path.indexOf("://");

if (idx !== -1) {

return idx + "://".length;

}

return 0;

}

ts.getRootLength = getRootLength;

ts.directorySeparator = "/";

var directorySeparatorCharCode = 47;

function getNormalizedParts(normalizedSlashedPath, rootLength) {

var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);

var normalized = [];

for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {

var part = parts_1[_i];

if (part !== ".") {

if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {

normalized.pop();

}

else {

if (part) {

normalized.push(part);

}

}

}

}