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

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;

var ExitStatus;

(function (ExitStatus) {

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

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

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

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

var TypeReferenceSerializationKind;

(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";

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

var DiagnosticCategory;

(function (DiagnosticCategory) {

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

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

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

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

var ModuleResolutionKind;

(function (ModuleResolutionKind) {

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

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

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

var ModuleKind;

(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["ES2015"] = 5] = "ES2015";

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

var Extension;

(function (Extension) {

Extension[Extension["Ts"] = 0] = "Ts";

Extension[Extension["Tsx"] = 1] = "Tsx";

Extension[Extension["Dts"] = 2] = "Dts";

Extension[Extension["Js"] = 3] = "Js";

Extension[Extension["Jsx"] = 4] = "Jsx";

Extension[Extension["LastTypeScriptExtension"] = 2] = "LastTypeScriptExtension";

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

})(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 = {}));

(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) {

ts.version = "2.2.0";

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

(function (ts) {

var createObject = Object.create;

ts.collator = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;

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 zipWith(arrayA, arrayB, callback) {

Debug.assert(arrayA.length === arrayB.length);

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

callback(arrayA[i], arrayB[i], i);

}

}

ts.zipWith = zipWith;

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++) {

result.push(f(array[i], i));

}

}

return result;

}

ts.map = map;

function sameMap(array, f) {

var result;

if (array) {

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

if (result) {

result.push(f(array[i], i));

}

else {

var item = array[i];

var mapped = f(item, i);

if (item !== mapped) {

result = array.slice(0, i);

result.push(mapped);

}

}

}

}

return result || array;

}

ts.sameMap = sameMap;

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 some(array, predicate) {

if (array) {

if (predicate) {

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

var v = array_5[_i];

if (predicate(v)) {

return true;

}

}

}

else {

return array.length > 0;

}

}

return false;

}

ts.some = some;

function concatenate(array1, array2) {

if (!some(array2))

return array1;

if (!some(array1))

return array2;

return array1.concat(array2);

}

ts.concatenate = concatenate;

function deduplicate(array, areEqual) {

var result;

if (array) {

result = [];

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

var item = array_6[_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 arrayIsEqualTo(array1, array2, equaler) {

if (!array1 || !array2) {

return array1 === array2;

}

if (array1.length !== array2.length) {

return false;

}

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

var equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];

if (!equals) {

return false;

}

}

return true;

}

ts.arrayIsEqualTo = arrayIsEqualTo;

function changesAffectModuleResolution(oldOptions, newOptions) {

return !oldOptions ||

(oldOptions.module !== newOptions.module) ||

(oldOptions.moduleResolution !== newOptions.moduleResolution) ||

(oldOptions.noResolve !== newOptions.noResolve) ||

(oldOptions.target !== newOptions.target) ||

(oldOptions.noLib !== newOptions.noLib) ||

(oldOptions.jsx !== newOptions.jsx) ||

(oldOptions.allowJs !== newOptions.allowJs) ||

(oldOptions.rootDir !== newOptions.rootDir) ||

(oldOptions.configFilePath !== newOptions.configFilePath) ||

(oldOptions.baseUrl !== newOptions.baseUrl) ||

(oldOptions.maxNodeModuleJsDepth !== newOptions.maxNodeModuleJsDepth) ||

!arrayIsEqualTo(oldOptions.lib, newOptions.lib) ||

!arrayIsEqualTo(oldOptions.typeRoots, newOptions.typeRoots) ||

!arrayIsEqualTo(oldOptions.rootDirs, newOptions.rootDirs) ||

!equalOwnProperties(oldOptions.paths, newOptions.paths);

}

ts.changesAffectModuleResolution = changesAffectModuleResolution;

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 relativeComplement(arrayA, arrayB, comparer, offsetA, offsetB) {

if (comparer === void 0) { comparer = compareValues; }

if (offsetA === void 0) { offsetA = 0; }

if (offsetB === void 0) { offsetB = 0; }

if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)

return arrayB;

var result = [];

outer: for (; offsetB < arrayB.length; offsetB++) {

inner: for (; offsetA < arrayA.length; offsetA++) {

switch (comparer(arrayB[offsetB], arrayA[offsetA])) {

case -1: break inner;

case 0: continue outer;

case 1: continue inner;

}

}

result.push(arrayB[offsetB]);

}

return result;

}

ts.relativeComplement = relativeComplement;

function sum(array, prop) {

var result = 0;

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

var v = array_7[_i];

result += v[prop];

}

return result;

}

ts.sum = sum;

function append(to, value) {

if (value === undefined)

return to;

if (to === undefined)

return [value];

to.push(value);

return to;

}

ts.append = append;

function addRange(to, from) {

if (from === undefined)

return to;

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

var v = from_1[_i];

to = append(to, v);

}

return to;

}

ts.addRange = addRange;

function stableSort(array, comparer) {

if (comparer === void 0) { comparer = compareValues; }

return array

.map(function (_, i) { return i; })

.sort(function (x, y) { return comparer(array[x], array[y]) || compareValues(x, y); })

.map(function (i) { return array[i]; });

}

ts.stableSort = stableSort;

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 lastOrUndefined(array) {

return array && array.length > 0

? array[array.length - 1]

: undefined;

}

ts.lastOrUndefined = lastOrUndefined;

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 replaceElement(array, index, value) {

var result = array.slice(0);

result[index] = value;

return result;

}

ts.replaceElement = replaceElement;

function binarySearch(array, value, comparer, offset) {

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

return -1;

}

var low = offset || 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 appendProperty(map, key, value) {

if (key === undefined || value === undefined)

return map;

if (map === undefined)

map = createMap();

map[key] = value;

return map;

}

ts.appendProperty = appendProperty;

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 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_8 = array; _i < array_8.length; _i++) {

var value = array_8[_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 noop() { }

ts.noop = noop;

function notImplemented() {

throw new Error("Not implemented");

}

ts.notImplemented = notImplemented;

function memoize(callback) {

var value;

return function () {

if (callback) {

value = callback();

callback = undefined;

}

return value;

};

}

ts.memoize = memoize;

function chain(a, b, c, d, e) {

if (e) {

var args_2 = [];

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

args_2[i] = arguments[i];

}

return function (t) { return compose.apply(void 0, map(args_2, function (f) { return f(t); })); };

}

else if (d) {

return function (t) { return compose(a(t), b(t), c(t), d(t)); };

}

else if (c) {

return function (t) { return compose(a(t), b(t), c(t)); };

}

else if (b) {

return function (t) { return compose(a(t), b(t)); };

}

else if (a) {

return function (t) { return compose(a(t)); };

}

else {

return function (_) { return function (u) { return u; }; };

}

}

ts.chain = chain;

function compose(a, b, c, d, e) {

if (e) {

var args_3 = [];

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

args_3[i] = arguments[i];

}

return function (t) { return reduceLeft(args_3, function (u, f) { return f(u); }, t); };

}

else if (d) {

return function (t) { return d(c(b(a(t)))); };

}

else if (c) {

return function (t) { return c(b(a(t))); };

}

else if (b) {

return function (t) { return b(a(t)); };

}

else if (a) {

return function (t) { return a(t); };

}

else {

return function (t) { return t; };

}

}

ts.compose = compose;

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);

}