relay-compiler-plus
Version:
A custom relay modern compiler that supports persisted queries
1,433 lines (1,430 loc) • 3.14 MB
JavaScript
/*! *****************************************************************************
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.
***************************************************************************** */
"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
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 NodeBuilderFlags;
(function (NodeBuilderFlags) {
NodeBuilderFlags[NodeBuilderFlags["None"] = 0] = "None";
NodeBuilderFlags[NodeBuilderFlags["NoTruncation"] = 1] = "NoTruncation";
NodeBuilderFlags[NodeBuilderFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
NodeBuilderFlags[NodeBuilderFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
NodeBuilderFlags[NodeBuilderFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
NodeBuilderFlags[NodeBuilderFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
NodeBuilderFlags[NodeBuilderFlags["WriteTypeParametersInQualifiedName"] = 512] = "WriteTypeParametersInQualifiedName";
NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 1024] = "AllowThisInObjectLiteral";
NodeBuilderFlags[NodeBuilderFlags["AllowQualifedNameInPlaceOfIdentifier"] = 2048] = "AllowQualifedNameInPlaceOfIdentifier";
NodeBuilderFlags[NodeBuilderFlags["AllowAnonymousIdentifier"] = 8192] = "AllowAnonymousIdentifier";
NodeBuilderFlags[NodeBuilderFlags["AllowEmptyUnionOrIntersection"] = 16384] = "AllowEmptyUnionOrIntersection";
NodeBuilderFlags[NodeBuilderFlags["AllowEmptyTuple"] = 32768] = "AllowEmptyTuple";
NodeBuilderFlags[NodeBuilderFlags["IgnoreErrors"] = 60416] = "IgnoreErrors";
NodeBuilderFlags[NodeBuilderFlags["InObjectTypeLiteral"] = 1048576] = "InObjectTypeLiteral";
NodeBuilderFlags[NodeBuilderFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
})(NodeBuilderFlags = ts.NodeBuilderFlags || (ts.NodeBuilderFlags = {}));
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[ModuleKind["ESNext"] = 6] = "ESNext";
})(ModuleKind = ts.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 = {}));
(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.set(markName, ts.timestamp());
counts.set(markName, (counts.get(markName) || 0) + 1);
profilerEvent(markName);
}
}
performance.mark = mark;
function measure(measureName, startMarkName, endMarkName) {
if (enabled) {
var end = endMarkName && marks.get(endMarkName) || ts.timestamp();
var start = startMarkName && marks.get(startMarkName) || profilerStart;
measures.set(measureName, (measures.get(measureName) || 0) + (end - start));
}
}
performance.measure = measure;
function getCount(markName) {
return counts && counts.get(markName) || 0;
}
performance.getCount = getCount;
function getDuration(measureName) {
return measures && measures.get(measureName) || 0;
}
performance.getDuration = getDuration;
function forEachMeasure(cb) {
measures.forEach(function (measure, key) {
cb(key, measure);
});
}
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.versionMajorMinor = "2.6";
ts.version = ts.versionMajorMinor + ".2";
})(ts || (ts = {}));
(function (ts) {
function isExternalModuleNameRelative(moduleName) {
return ts.pathIsRelative(moduleName) || ts.isRootedDiskPath(moduleName);
}
ts.isExternalModuleNameRelative = isExternalModuleNameRelative;
})(ts || (ts = {}));
(function (ts) {
ts.collator = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator(undefined, { usage: "sort", sensitivity: "accent" }) : undefined;
ts.localeCompareIsCorrect = ts.collator && ts.collator.compare("a", "B") < 0;
function createDictionaryObject() {
var map = Object.create(null);
map.__ = undefined;
delete map.__;
return map;
}
function createMap() {
return new MapCtr();
}
ts.createMap = createMap;
function createUnderscoreEscapedMap() {
return new MapCtr();
}
ts.createUnderscoreEscapedMap = createUnderscoreEscapedMap;
function createSymbolTable(symbols) {
var result = createMap();
if (symbols) {
for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
var symbol = symbols_1[_i];
result.set(symbol.escapedName, symbol);
}
}
return result;
}
ts.createSymbolTable = createSymbolTable;
function createMapFromTemplate(template) {
var map = new MapCtr();
for (var key in template) {
if (hasOwnProperty.call(template, key)) {
map.set(key, template[key]);
}
}
return map;
}
ts.createMapFromTemplate = createMapFromTemplate;
var MapCtr = typeof Map !== "undefined" && "entries" in Map.prototype ? Map : shimMap();
function shimMap() {
var MapIterator = (function () {
function MapIterator(data, selector) {
this.index = 0;
this.data = data;
this.selector = selector;
this.keys = Object.keys(data);
}
MapIterator.prototype.next = function () {
var index = this.index;
if (index < this.keys.length) {
this.index++;
return { value: this.selector(this.data, this.keys[index]), done: false };
}
return { value: undefined, done: true };
};
return MapIterator;
}());
return (function () {
function class_1() {
this.data = createDictionaryObject();
this.size = 0;
}
class_1.prototype.get = function (key) {
return this.data[key];
};
class_1.prototype.set = function (key, value) {
if (!this.has(key)) {
this.size++;
}
this.data[key] = value;
return this;
};
class_1.prototype.has = function (key) {
return key in this.data;
};
class_1.prototype.delete = function (key) {
if (this.has(key)) {
this.size--;
delete this.data[key];
return true;
}
return false;
};
class_1.prototype.clear = function () {
this.data = createDictionaryObject();
this.size = 0;
};
class_1.prototype.keys = function () {
return new MapIterator(this.data, function (_data, key) { return key; });
};
class_1.prototype.values = function () {
return new MapIterator(this.data, function (data, key) { return data[key]; });
};
class_1.prototype.entries = function () {
return new MapIterator(this.data, function (data, key) { return [key, data[key]]; });
};
class_1.prototype.forEach = function (action) {
for (var key in this.data) {
action(this.data[key], key);
}
};
return class_1;
}());
}
function toPath(fileName, basePath, getCanonicalFileName) {
var nonCanonicalizedPath = isRootedDiskPath(fileName)
? normalizePath(fileName)
: getNormalizedAbsolutePath(fileName, basePath);
return getCanonicalFileName(nonCanonicalizedPath);
}
ts.toPath = toPath;
function length(array) {
return array ? array.length : 0;
}
ts.length = length;
function forEach(array, callback) {
if (array) {
for (var i = 0; i < array.length; i++) {
var result = callback(array[i], i);
if (result) {
return result;
}
}
}
return undefined;
}
ts.forEach = forEach;
function firstDefined(array, callback) {
for (var i = 0; i < array.length; i++) {
var result = callback(array[i], i);
if (result !== undefined) {
return result;
}
}
return undefined;
}
ts.firstDefined = firstDefined;
function findAncestor(node, callback) {
while (node) {
var result = callback(node);
if (result === "quit") {
return undefined;
}
else if (result) {
return node;
}
node = node.parent;
}
return undefined;
}
ts.findAncestor = findAncestor;
function zipWith(arrayA, arrayB, callback) {
var result = [];
Debug.assert(arrayA.length === arrayB.length);
for (var i = 0; i < arrayA.length; i++) {
result.push(callback(arrayA[i], arrayB[i], i));
}
return result;
}
ts.zipWith = zipWith;
function zipToMap(keys, values) {
Debug.assert(keys.length === values.length);
var map = createMap();
for (var i = 0; i < keys.length; ++i) {
map.set(keys[i], values[i]);
}
return map;
}
ts.zipToMap = zipToMap;
function every(array, callback) {
if (array) {
for (var i = 0; i < array.length; i++) {
if (!callback(array[i], i)) {
return false;
}
}
}
return true;
}
ts.every = every;
function find(array, predicate) {
for (var i = 0; i < array.length; i++) {
var value = array[i];
if (predicate(value, i)) {
return value;
}
}
return undefined;
}
ts.find = find;
function findLast(array, predicate) {
for (var i = array.length - 1; i >= 0; i--) {
var value = array[i];
if (predicate(value, i)) {
return value;
}
}
return undefined;
}
ts.findLast = findLast;
function findIndex(array, predicate) {
for (var i = 0; i < array.length; i++) {
if (predicate(array[i], i)) {
return i;
}
}
return -1;
}
ts.findIndex = findIndex;
function findMap(array, callback) {
for (var i = 0; i < array.length; 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; i < array.length; i++) {
if (array[i] === value) {
return i;
}
}
}
return -1;
}
ts.indexOf = indexOf;
function indexOfAnyCharCode(text, charCodes, start) {
for (var i = start || 0; i < text.length; 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 filterMutate(array, f) {
var outIndex = 0;
for (var i = 0; i < array.length; i++) {
if (f(array[i], i, array)) {
array[outIndex] = array[i];
outIndex++;
}
}
array.length = outIndex;
}
ts.filterMutate = filterMutate;
function clear(array) {
array.length = 0;
}
ts.clear = clear;
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_2 = array; _i < array_2.length; _i++) {
var v = array_2[_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 flatMapIter(iter, mapfn) {
var result = [];
while (true) {
var _a = iter.next(), value = _a.value, done = _a.done;
if (done)
break;
var res = mapfn(value);
if (res) {
if (isArray(res)) {
result.push.apply(result, res);
}
else {
result.push(res);
}
}
}
return result;
}
ts.flatMapIter = flatMapIter;
function sameFlatMap(array, mapfn) {
var result;
if (array) {
for (var i = 0; i < array.length; i++) {
var item = array[i];
var mapped = mapfn(item, i);
if (result || item !== mapped || isArray(mapped)) {
if (!result) {
result = array.slice(0, i);
}
if (isArray(mapped)) {
addRange(result, mapped);
}
else {
result.push(mapped);
}
}
}
}
return result || array;
}
ts.sameFlatMap = sameFlatMap;
function mapDefined(array, mapFn) {
var result = [];
if (array) {
for (var i = 0; i < array.length; i++) {
var item = array[i];
var mapped = mapFn(item, i);
if (mapped !== undefined) {
result.push(mapped);
}
}
}
return result;
}
ts.mapDefined = mapDefined;
function mapDefinedIter(iter, mapFn) {
var result = [];
while (true) {
var _a = iter.next(), value = _a.value, done = _a.done;
if (done)
break;
var res = mapFn(value);
if (res !== undefined) {
result.push(res);
}
}
return result;
}
ts.mapDefinedIter = mapDefinedIter;
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 mapEntries(map, f) {
if (!map) {
return undefined;
}
var result = createMap();
map.forEach(function (value, key) {
var _a = f(key, value), newKey = _a[0], newValue = _a[1];
result.set(newKey, newValue);
});
return result;
}
ts.mapEntries = mapEntries;
function some(array, predicate) {
if (array) {
if (predicate) {
for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
var v = array_3[_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_4 = array; _i < array_4.length; _i++) {
var item = array_4[_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_5 = array; _i < array_5.length; _i++) {
var v = array_5[_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 toOffset(array, offset) {
return offset < 0 ? array.length + offset : offset;
}
function addRange(to, from, start, end) {
if (from === undefined || from.length === 0)
return to;
if (to === undefined)
return from.slice(start, end);
start = start === undefined ? 0 : toOffset(from, start);
end = end === undefined ? from.length : toOffset(from, end);
for (var i = start; i < end && i < from.length; i++) {
var v = from[i];
if (v !== undefined) {
to.push(from[i]);
}
}
return to;
}
ts.addRange = addRange;
function pushIfUnique(array, toAdd) {
if (contains(array, toAdd)) {
return false;
}
else {
array.push(toAdd);
return true;
}
}
ts.pushIfUnique = pushIfUnique;
function appendIfUnique(array, toAdd) {
if (array) {
pushIfUnique(array, toAdd);
return array;
}
else {
return [toAdd];
}
}
ts.appendIfUnique = appendIfUnique;
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 elementAt(array, offset) {
if (array) {
offset = toOffset(array, offset);
if (offset < array.length) {
return array[offset];
}
}
return undefined;
}
ts.elementAt = elementAt;
function firstOrUndefined(array) {
return elementAt(array, 0);
}
ts.firstOrUndefined = firstOrUndefined;
function first(array) {
Debug.assert(array.length !== 0);
return array[0];
}
ts.first = first;
function lastOrUndefined(array) {
return elementAt(array, -1);
}
ts.lastOrUndefined = lastOrUndefined;
function last(array) {
Debug.assert(array.length !== 0);
return array[array.length - 1];
}
ts.last = last;
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 getOwnValues(sparseArray) {
var values = [];
for (var key in sparseArray) {
if (hasOwnProperty.call(sparseArray, key)) {
values.push(sparseArray[key]);
}
}
return values;
}
ts.getOwnValues = getOwnValues;
function arrayFrom(iterator, map) {
var result = [];
for (var _a = iterator.next(), value = _a.value, done = _a.done; !done; _b = iterator.next(), value = _b.value, done = _b.done, _b) {
result.push(map ? map(value) : value);
}
return result;
var _b;
}
ts.arrayFrom = arrayFrom;
function forEachEntry(map, callback) {
var iterator = map.entries();
for (var _a = iterator.next(), pair = _a.value, done = _a.done; !done; _b = iterator.next(), pair = _b.value, done = _b.done, _b) {
var key = pair[0], value = pair[1];
var result = callback(value, key);
if (result) {
return result;
}
}
return undefined;
var _b;
}
ts.forEachEntry = forEachEntry;
function forEachKey(map, callback) {
var iterator = map.keys();
for (var _a = iterator.next(), key = _a.value, done = _a.done; !done; _b = iterator.next(), key = _b.value, done = _b.done, _b) {
var result = callback(key);
if (result) {
return result;
}
}
return undefined;
var _b;
}
ts.forEachKey = forEachKey;
function copyEntries(source, target) {
source.forEach(function (value, key) {
target.set(key, value);
});
}
ts.copyEntries = copyEntries;
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 p in arg) {
if (hasProperty(arg, p)) {
t[p] = arg[p];
}
}
}
return t;
}
ts.assign = assign;
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_6 = array; _i < array_6.length; _i++) {
var value = array_6[_i];
result.set(makeKey(value), makeValue ? makeValue(value) : value);
}
return result;
}
ts.arrayToMap = arrayToMap;
function arrayToNumericMap(array, makeKey) {
var result = [];
for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
var value = array_7[_i];
result[makeKey(value)] = value;
}
return result;
}
ts.arrayToNumericMap = arrayToNumericMap;
function arrayToSet(array, makeKey) {
return arrayToMap(array, makeKey || (function (s) { return s; }), function () { return true; });
}
ts.arrayToSet = arrayToSet;
function cloneMap(map) {
var clone = createMap();
copyEntries(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 createMultiMap() {
var map = createMap();
map.add = multiMapAdd;
map.remove = multiMapRemove;
return map;
}
ts.createMultiMap = createMultiMap;
function multiMapAdd(key, value) {
var values = this.get(key);
if (values) {
values.push(value);
}
else {
this.set(key, values = [value]);
}
return values;
}
function multiMapRemove(key, value) {
var values = this.get(key);
if (values) {
unorderedRemoveItem(values, value);
if (!values.length) {
this.delete(key);
}
}
}
function isArray(value) {
return Array.isArray ? Array.isArray(value) : value instanceof Array;
}
ts.isArray = isArray;
function toArray(value) {
return isArray(value) ? value : [value];
}
ts.toArray = toArray;
function isString(text) {
return typeof text === "string";
}
ts.isString = isString;
function tryCast(value, test) {
return value !== undefined && test(value) ? value : undefined;
}
ts.tryCast = tryCast;
function cast(value, test) {
if (value !== undefined && test(value))
return value;
Debug.fail("Invalid cast. The supplied value did not pass the test '" + Debug.getFunctionName(test) + "'.");
}
ts.cast = cast;
function noop() { }
ts.noop = noop;
function returnFalse() { return false; }
ts.returnFalse = returnFalse;
function returnTrue() { return true; }
ts.returnTrue = returnTrue;
function identity(x) { return x; }
ts.identity = identity;
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.formatStringFromArgs = formatStringFromArgs;
ts.localizedDiagnosticMessages = undefined;
function getLocaleSpecificMessage(message) {
return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message.key] || message.message;
}
ts.getLocaleSpecificMessage = getLocaleSpecificMessage;
function createFileDiagnostic(file, start, length, message) {
Debug.assertGreaterThanOrEqual(start, 0);
Debug.assertGreaterThanOrEqual(length, 0);
if (file) {
Debug.assertLessThanOrEqual(start, file.text.length);
Debug.assertLessThanOrEqual(start + length, 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 createCompilerDiagnosticFromMessageChain(chain) {
return {
file: undefined,
start: undefined,
length: undefined,
code: chain.code,
category: chain.category,
messageText: chain.next ? chain : chain.messageText
};
}
ts.createCompilerDiagnosticFromMessageChain = createCompilerDiagnosticFromMessageChain;
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 (ts.collator) {
var result = ts.localeCompareIsCorrect ?
ts.collator.compare(a, b) :
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 = isString(text1) ? text1 : text1.messageText;
var string2 = isString(text2) ? text2 : text2.messageText;
var res = compareValues(string1, string2);
if (res) {
return res;
}
text1 = isString(text1) ? undefined : text1.next;
text2 = isString(text2) ? 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 (p