diff --git a/.gitignore b/.gitignore index ff3dd892..6373265d 100644 --- a/.gitignore +++ b/.gitignore @@ -176,3 +176,4 @@ $RECYCLE.BIN/ lib esm next +bin/ttsc diff --git a/bin/ttsc b/bin/ttsc new file mode 100755 index 00000000..40322d6c --- /dev/null +++ b/bin/ttsc @@ -0,0 +1,87205 @@ +#!/usr/bin/env node + +"use strict"; +var ts = new Proxy({}, { + set: function (obj, prop, value) { + if (prop === 'sys') { + value.getExecutingFilePath = function getExecutingFilePath() { + return require.resolve('typescript/lib/tsc.js'); + }; + } + return Reflect.set(obj, prop, value); + }, +}); +//# sourceMappingURL=bin.js.map +/*! ***************************************************************************** +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 __spreadArrays = (this && this.__spreadArrays) || function () { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +}; +var __assign = (this && this.__assign) || function () { + __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; + }; + return __assign.apply(this, arguments); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; +}; +var ts; +(function (ts) { + ts.versionMajorMinor = "3.8"; + ts.version = "3.8.3"; + function tryGetNativeMap() { + return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined; + } + ts.tryGetNativeMap = tryGetNativeMap; + ts.Map = tryGetNativeMap() || (function () { + if (typeof ts.createMapShim === "function") { + return ts.createMapShim(); + } + throw new Error("TypeScript requires an environment that provides a compatible native Map implementation."); + })(); +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.emptyArray = []; + function createMap() { + return new ts.Map(); + } + ts.createMap = createMap; + function createMapFromEntries(entries) { + var map = createMap(); + for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) { + var _a = entries_1[_i], key = _a[0], value = _a[1]; + map.set(key, value); + } + return map; + } + ts.createMapFromEntries = createMapFromEntries; + function createMapFromTemplate(template) { + var map = new ts.Map(); + for (var key in template) { + if (hasOwnProperty.call(template, key)) { + map.set(key, template[key]); + } + } + return map; + } + ts.createMapFromTemplate = createMapFromTemplate; + 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 forEachRight(array, callback) { + if (array) { + for (var i = array.length - 1; i >= 0; i--) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + } + return undefined; + } + ts.forEachRight = forEachRight; + function firstDefined(array, callback) { + if (array === undefined) { + return undefined; + } + 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 firstDefinedIterator(iter, callback) { + while (true) { + var iterResult = iter.next(); + if (iterResult.done) { + return undefined; + } + var result = callback(iterResult.value); + if (result !== undefined) { + return result; + } + } + } + ts.firstDefinedIterator = firstDefinedIterator; + function zipWith(arrayA, arrayB, callback) { + var result = []; + ts.Debug.assertEqual(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 zipToIterator(arrayA, arrayB) { + ts.Debug.assertEqual(arrayA.length, arrayB.length); + var i = 0; + return { + next: function () { + if (i === arrayA.length) { + return { value: undefined, done: true }; + } + i++; + return { value: [arrayA[i - 1], arrayB[i - 1]], done: false }; + } + }; + } + ts.zipToIterator = zipToIterator; + function zipToMap(keys, values) { + ts.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, startIndex) { + for (var i = startIndex || 0; i < array.length; i++) { + if (predicate(array[i], i)) { + return i; + } + } + return -1; + } + ts.findIndex = findIndex; + function findLastIndex(array, predicate, startIndex) { + for (var i = startIndex === undefined ? array.length - 1 : startIndex; i >= 0; i--) { + if (predicate(array[i], i)) { + return i; + } + } + return -1; + } + ts.findLastIndex = findLastIndex; + function findMap(array, callback) { + for (var i = 0; i < array.length; i++) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + return ts.Debug.fail(); + } + ts.findMap = findMap; + function contains(array, value, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + if (array) { + for (var _i = 0, array_1 = array; _i < array_1.length; _i++) { + var v = array_1[_i]; + if (equalityComparer(v, value)) { + return true; + } + } + } + return false; + } + ts.contains = contains; + function arraysEqual(a, b, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + return a.length === b.length && a.every(function (x, i) { return equalityComparer(x, b[i]); }); + } + ts.arraysEqual = arraysEqual; + 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 mapIterator(iter, mapFn) { + return { + next: function () { + var iterRes = iter.next(); + return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false }; + } + }; + } + ts.mapIterator = mapIterator; + function sameMap(array, f) { + if (array) { + for (var i = 0; i < array.length; i++) { + var item = array[i]; + var mapped = f(item, i); + if (item !== mapped) { + var result = array.slice(0, i); + result.push(mapped); + for (i++; i < array.length; i++) { + result.push(f(array[i], i)); + } + return result; + } + } + } + return array; + } + ts.sameMap = sameMap; + function flatten(array) { + var 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) { + for (var i = 0; i < array.length; i++) { + var v = mapfn(array[i], i); + if (v) { + if (isArray(v)) { + result = addRange(result, v); + } + else { + result = append(result, v); + } + } + } + } + return result || ts.emptyArray; + } + ts.flatMap = flatMap; + function flatMapToMutable(array, mapfn) { + var result = []; + if (array) { + 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.flatMapToMutable = flatMapToMutable; + function flatMapIterator(iter, mapfn) { + var first = iter.next(); + if (first.done) { + return ts.emptyIterator; + } + var currentIter = getIterator(first.value); + return { + next: function () { + while (true) { + var currentRes = currentIter.next(); + if (!currentRes.done) { + return currentRes; + } + var iterRes = iter.next(); + if (iterRes.done) { + return iterRes; + } + currentIter = getIterator(iterRes.value); + } + }, + }; + function getIterator(x) { + var res = mapfn(x); + return res === undefined ? ts.emptyIterator : isArray(res) ? arrayIterator(res) : res; + } + } + ts.flatMapIterator = flatMapIterator; + 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 mapAllOrFail(array, mapFn) { + var result = []; + for (var i = 0; i < array.length; i++) { + var mapped = mapFn(array[i], i); + if (mapped === undefined) { + return undefined; + } + result.push(mapped); + } + return result; + } + ts.mapAllOrFail = mapAllOrFail; + function mapDefined(array, mapFn) { + var result = []; + if (array) { + for (var i = 0; i < array.length; i++) { + var mapped = mapFn(array[i], i); + if (mapped !== undefined) { + result.push(mapped); + } + } + } + return result; + } + ts.mapDefined = mapDefined; + function mapDefinedIterator(iter, mapFn) { + return { + next: function () { + while (true) { + var res = iter.next(); + if (res.done) { + return res; + } + var value = mapFn(res.value); + if (value !== undefined) { + return { value: value, done: false }; + } + } + } + }; + } + ts.mapDefinedIterator = mapDefinedIterator; + function mapDefinedMap(map, mapValue, mapKey) { + if (mapKey === void 0) { mapKey = identity; } + var result = createMap(); + map.forEach(function (value, key) { + var mapped = mapValue(value, key); + if (mapped !== undefined) { + result.set(mapKey(key), mapped); + } + }); + return result; + } + ts.mapDefinedMap = mapDefinedMap; + ts.emptyIterator = { next: function () { return ({ value: undefined, done: true }); } }; + function singleIterator(value) { + var done = false; + return { + next: function () { + var wasDone = done; + done = true; + return wasDone ? { value: undefined, done: true } : { value: value, done: false }; + } + }; + } + ts.singleIterator = singleIterator; + 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 getRangesWhere(arr, pred, cb) { + var start; + for (var i = 0; i < arr.length; i++) { + if (pred(arr[i])) { + start = start === undefined ? i : start; + } + else { + if (start !== undefined) { + cb(start, i); + start = undefined; + } + } + } + if (start !== undefined) + cb(start, arr.length); + } + ts.getRangesWhere = getRangesWhere; + function concatenate(array1, array2) { + if (!some(array2)) + return array1; + if (!some(array1)) + return array2; + return __spreadArrays(array1, array2); + } + ts.concatenate = concatenate; + function selectIndex(_, i) { + return i; + } + function indicesOf(array) { + return array.map(selectIndex); + } + ts.indicesOf = indicesOf; + function deduplicateRelational(array, equalityComparer, comparer) { + var indices = indicesOf(array); + stableSortIndices(array, indices, comparer); + var last = array[indices[0]]; + var deduplicated = [indices[0]]; + for (var i = 1; i < indices.length; i++) { + var index = indices[i]; + var item = array[index]; + if (!equalityComparer(last, item)) { + deduplicated.push(index); + last = item; + } + } + deduplicated.sort(); + return deduplicated.map(function (i) { return array[i]; }); + } + function deduplicateEquality(array, equalityComparer) { + var result = []; + for (var _i = 0, array_4 = array; _i < array_4.length; _i++) { + var item = array_4[_i]; + pushIfUnique(result, item, equalityComparer); + } + return result; + } + function deduplicate(array, equalityComparer, comparer) { + return array.length === 0 ? [] : + array.length === 1 ? array.slice() : + comparer ? deduplicateRelational(array, equalityComparer, comparer) : + deduplicateEquality(array, equalityComparer); + } + ts.deduplicate = deduplicate; + function deduplicateSorted(array, comparer) { + if (array.length === 0) + return ts.emptyArray; + var last = array[0]; + var deduplicated = [last]; + for (var i = 1; i < array.length; i++) { + var next = array[i]; + switch (comparer(next, last)) { + case true: + case 0: + continue; + case -1: + return ts.Debug.fail("Array is unsorted."); + } + deduplicated.push(last = next); + } + return deduplicated; + } + function insertSorted(array, insert, compare) { + if (array.length === 0) { + array.push(insert); + return; + } + var insertIndex = binarySearch(array, insert, identity, compare); + if (insertIndex < 0) { + array.splice(~insertIndex, 0, insert); + } + } + ts.insertSorted = insertSorted; + function sortAndDeduplicate(array, comparer, equalityComparer) { + return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive); + } + ts.sortAndDeduplicate = sortAndDeduplicate; + function arrayIsEqualTo(array1, array2, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + if (!array1 || !array2) { + return array1 === array2; + } + if (array1.length !== array2.length) { + return false; + } + for (var i = 0; i < array1.length; i++) { + if (!equalityComparer(array1[i], array2[i], i)) { + return false; + } + } + return true; + } + ts.arrayIsEqualTo = arrayIsEqualTo; + 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) { + if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0) + return arrayB; + var result = []; + loopB: for (var offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) { + if (offsetB > 0) { + ts.Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0); + } + loopA: for (var startA = offsetA; offsetA < arrayA.length; offsetA++) { + if (offsetA > startA) { + ts.Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0); + } + switch (comparer(arrayB[offsetB], arrayA[offsetA])) { + case -1: + result.push(arrayB[offsetB]); + continue loopB; + case 0: + continue loopB; + case 1: + continue loopA; + } + } + } + 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++) { + if (from[i] !== undefined) { + to.push(from[i]); + } + } + return to; + } + ts.addRange = addRange; + function pushIfUnique(array, toAdd, equalityComparer) { + if (contains(array, toAdd, equalityComparer)) { + return false; + } + else { + array.push(toAdd); + return true; + } + } + ts.pushIfUnique = pushIfUnique; + function appendIfUnique(array, toAdd, equalityComparer) { + if (array) { + pushIfUnique(array, toAdd, equalityComparer); + return array; + } + else { + return [toAdd]; + } + } + ts.appendIfUnique = appendIfUnique; + function stableSortIndices(array, indices, comparer) { + indices.sort(function (x, y) { return comparer(array[x], array[y]) || compareValues(x, y); }); + } + function sort(array, comparer) { + return (array.length === 0 ? array : array.slice().sort(comparer)); + } + ts.sort = sort; + function arrayIterator(array) { + var i = 0; + return { next: function () { + if (i === array.length) { + return { value: undefined, done: true }; + } + else { + i++; + return { value: array[i - 1], done: false }; + } + } }; + } + ts.arrayIterator = arrayIterator; + function arrayReverseIterator(array) { + var i = array.length; + return { + next: function () { + if (i === 0) { + return { value: undefined, done: true }; + } + else { + i--; + return { value: array[i], done: false }; + } + } + }; + } + ts.arrayReverseIterator = arrayReverseIterator; + function stableSort(array, comparer) { + var indices = indicesOf(array); + stableSortIndices(array, indices, comparer); + return indices.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 array.length === 0 ? undefined : array[0]; + } + ts.firstOrUndefined = firstOrUndefined; + function first(array) { + ts.Debug.assert(array.length !== 0); + return array[0]; + } + ts.first = first; + function lastOrUndefined(array) { + return array.length === 0 ? undefined : array[array.length - 1]; + } + ts.lastOrUndefined = lastOrUndefined; + function last(array) { + ts.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, keySelector, keyComparer, offset) { + return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset); + } + ts.binarySearch = binarySearch; + function binarySearchKey(array, key, keySelector, keyComparer, offset) { + if (!some(array)) { + return -1; + } + var low = offset || 0; + var high = array.length - 1; + while (low <= high) { + var middle = low + ((high - low) >> 1); + var midKey = keySelector(array[middle]); + switch (keyComparer(midKey, key)) { + case -1: + low = middle + 1; + break; + case 0: + return middle; + case 1: + high = middle - 1; + break; + } + } + return ~low; + } + ts.binarySearchKey = binarySearchKey; + 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; + 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 getAllKeys(obj) { + var result = []; + do { + var names = Object.getOwnPropertyNames(obj); + for (var _i = 0, names_1 = names; _i < names_1.length; _i++) { + var name = names_1[_i]; + pushIfUnique(result, name); + } + } while (obj = Object.getPrototypeOf(obj)); + return result; + } + ts.getAllKeys = getAllKeys; + 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 iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + result.push(map ? map(iterResult.value) : iterResult.value); + } + return result; + } + ts.arrayFrom = arrayFrom; + 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]; + if (arg === undefined) + continue; + for (var p in arg) { + if (hasProperty(arg, p)) { + t[p] = arg[p]; + } + } + } + return t; + } + ts.assign = assign; + function equalOwnProperties(left, right, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + 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)) + return false; + if (!equalityComparer(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) { + if (makeValue === void 0) { makeValue = identity; } + var result = createMap(); + for (var _i = 0, array_6 = array; _i < array_6.length; _i++) { + var value = array_6[_i]; + var key = makeKey(value); + if (key !== undefined) + result.set(key, makeValue(value)); + } + return result; + } + ts.arrayToMap = arrayToMap; + function arrayToNumericMap(array, makeKey, makeValue) { + if (makeValue === void 0) { makeValue = identity; } + var result = []; + for (var _i = 0, array_7 = array; _i < array_7.length; _i++) { + var value = array_7[_i]; + result[makeKey(value)] = makeValue(value); + } + return result; + } + ts.arrayToNumericMap = arrayToNumericMap; + function arrayToMultiMap(values, makeKey, makeValue) { + if (makeValue === void 0) { makeValue = identity; } + var result = createMultiMap(); + for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { + var value = values_1[_i]; + result.add(makeKey(value), makeValue(value)); + } + return result; + } + ts.arrayToMultiMap = arrayToMultiMap; + function group(values, getGroupId, resultSelector) { + if (resultSelector === void 0) { resultSelector = identity; } + return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector); + } + ts.group = group; + 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 copyProperties(first, second) { + for (var id in second) { + if (hasOwnProperty.call(second, id)) { + first[id] = second[id]; + } + } + } + ts.copyProperties = copyProperties; + function maybeBind(obj, fn) { + return fn ? fn.bind(obj) : undefined; + } + ts.maybeBind = maybeBind; + function mapMap(map, f) { + var result = createMap(); + map.forEach(function (t, key) { return result.set.apply(result, (f(t, key))); }); + return result; + } + ts.mapMap = mapMap; + 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 isNumber(x) { + return typeof x === "number"; + } + ts.isNumber = isNumber; + 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; + return ts.Debug.fail("Invalid cast. The supplied value " + value + " did not pass the test '" + ts.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 returnUndefined() { return undefined; } + ts.returnUndefined = returnUndefined; + function identity(x) { return x; } + ts.identity = identity; + function toLowerCase(x) { return x.toLowerCase(); } + ts.toLowerCase = toLowerCase; + var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g; + function toFileNameLowerCase(x) { + return fileNameLowerCaseRegExp.test(x) ? + x.replace(fileNameLowerCaseRegExp, toLowerCase) : + x; + } + ts.toFileNameLowerCase = toFileNameLowerCase; + 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 compose(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 reduceLeft(args_2, 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 equateValues(a, b) { + return a === b; + } + ts.equateValues = equateValues; + function equateStringsCaseInsensitive(a, b) { + return a === b + || a !== undefined + && b !== undefined + && a.toUpperCase() === b.toUpperCase(); + } + ts.equateStringsCaseInsensitive = equateStringsCaseInsensitive; + function equateStringsCaseSensitive(a, b) { + return equateValues(a, b); + } + ts.equateStringsCaseSensitive = equateStringsCaseSensitive; + function compareComparableValues(a, b) { + return a === b ? 0 : + a === undefined ? -1 : + b === undefined ? 1 : + a < b ? -1 : + 1; + } + function compareValues(a, b) { + return compareComparableValues(a, b); + } + ts.compareValues = compareValues; + function compareTextSpans(a, b) { + return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length); + } + ts.compareTextSpans = compareTextSpans; + function min(a, b, compare) { + return compare(a, b) === -1 ? a : b; + } + ts.min = min; + function compareStringsCaseInsensitive(a, b) { + if (a === b) + return 0; + if (a === undefined) + return -1; + if (b === undefined) + return 1; + a = a.toUpperCase(); + b = b.toUpperCase(); + return a < b ? -1 : a > b ? 1 : 0; + } + ts.compareStringsCaseInsensitive = compareStringsCaseInsensitive; + function compareStringsCaseSensitive(a, b) { + return compareComparableValues(a, b); + } + ts.compareStringsCaseSensitive = compareStringsCaseSensitive; + function getStringComparer(ignoreCase) { + return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive; + } + ts.getStringComparer = getStringComparer; + var createUIStringComparer = (function () { + var defaultComparer; + var enUSComparer; + var stringComparerFactory = getStringComparerFactory(); + return createStringComparer; + function compareWithCallback(a, b, comparer) { + if (a === b) + return 0; + if (a === undefined) + return -1; + if (b === undefined) + return 1; + var value = comparer(a, b); + return value < 0 ? -1 : value > 0 ? 1 : 0; + } + function createIntlCollatorStringComparer(locale) { + var comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare; + return function (a, b) { return compareWithCallback(a, b, comparer); }; + } + function createLocaleCompareStringComparer(locale) { + if (locale !== undefined) + return createFallbackStringComparer(); + return function (a, b) { return compareWithCallback(a, b, compareStrings); }; + function compareStrings(a, b) { + return a.localeCompare(b); + } + } + function createFallbackStringComparer() { + return function (a, b) { return compareWithCallback(a, b, compareDictionaryOrder); }; + function compareDictionaryOrder(a, b) { + return compareStrings(a.toUpperCase(), b.toUpperCase()) || compareStrings(a, b); + } + function compareStrings(a, b) { + return a < b ? -1 : a > b ? 1 : 0; + } + } + function getStringComparerFactory() { + if (typeof Intl === "object" && typeof Intl.Collator === "function") { + return createIntlCollatorStringComparer; + } + if (typeof String.prototype.localeCompare === "function" && + typeof String.prototype.toLocaleUpperCase === "function" && + "a".localeCompare("B") < 0) { + return createLocaleCompareStringComparer; + } + return createFallbackStringComparer; + } + function createStringComparer(locale) { + if (locale === undefined) { + return defaultComparer || (defaultComparer = stringComparerFactory(locale)); + } + else if (locale === "en-US") { + return enUSComparer || (enUSComparer = stringComparerFactory(locale)); + } + else { + return stringComparerFactory(locale); + } + } + })(); + var uiComparerCaseSensitive; + var uiLocale; + function getUILocale() { + return uiLocale; + } + ts.getUILocale = getUILocale; + function setUILocale(value) { + if (uiLocale !== value) { + uiLocale = value; + uiComparerCaseSensitive = undefined; + } + } + ts.setUILocale = setUILocale; + function compareStringsCaseSensitiveUI(a, b) { + var comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = createUIStringComparer(uiLocale)); + return comparer(a, b); + } + ts.compareStringsCaseSensitiveUI = compareStringsCaseSensitiveUI; + function compareProperties(a, b, key, comparer) { + return a === b ? 0 : + a === undefined ? -1 : + b === undefined ? 1 : + comparer(a[key], b[key]); + } + ts.compareProperties = compareProperties; + function compareBooleans(a, b) { + return compareValues(a ? 1 : 0, b ? 1 : 0); + } + ts.compareBooleans = compareBooleans; + function getSpellingSuggestion(name, candidates, getName) { + var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34)); + var bestDistance = Math.floor(name.length * 0.4) + 1; + var bestCandidate; + var justCheckExactMatches = false; + var nameLowerCase = name.toLowerCase(); + for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) { + var candidate = candidates_1[_i]; + var candidateName = getName(candidate); + if (candidateName !== undefined && Math.abs(candidateName.length - nameLowerCase.length) <= maximumLengthDifference) { + var candidateNameLowerCase = candidateName.toLowerCase(); + if (candidateNameLowerCase === nameLowerCase) { + if (candidateName === name) { + continue; + } + return candidate; + } + if (justCheckExactMatches) { + continue; + } + if (candidateName.length < 3) { + continue; + } + var distance = levenshteinWithMax(nameLowerCase, candidateNameLowerCase, bestDistance - 1); + if (distance === undefined) { + continue; + } + if (distance < 3) { + justCheckExactMatches = true; + bestCandidate = candidate; + } + else { + ts.Debug.assert(distance < bestDistance); + bestDistance = distance; + bestCandidate = candidate; + } + } + } + return bestCandidate; + } + ts.getSpellingSuggestion = getSpellingSuggestion; + function levenshteinWithMax(s1, s2, max) { + var previous = new Array(s2.length + 1); + var current = new Array(s2.length + 1); + var big = max + 1; + for (var i = 0; i <= s2.length; i++) { + previous[i] = i; + } + for (var i = 1; i <= s1.length; i++) { + var c1 = s1.charCodeAt(i - 1); + var minJ = i > max ? i - max : 1; + var maxJ = s2.length > max + i ? max + i : s2.length; + current[0] = i; + var colMin = i; + for (var j = 1; j < minJ; j++) { + current[j] = big; + } + for (var j = minJ; j <= maxJ; j++) { + var dist = c1 === s2.charCodeAt(j - 1) + ? previous[j - 1] + : Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + 2); + current[j] = dist; + colMin = Math.min(colMin, dist); + } + for (var j = maxJ + 1; j <= s2.length; j++) { + current[j] = big; + } + if (colMin > max) { + return undefined; + } + var temp = previous; + previous = current; + current = temp; + } + var res = previous[s2.length]; + return res > max ? undefined : res; + } + function endsWith(str, suffix) { + var expectedPos = str.length - suffix.length; + return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos; + } + ts.endsWith = endsWith; + function removeSuffix(str, suffix) { + return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str; + } + ts.removeSuffix = removeSuffix; + function tryRemoveSuffix(str, suffix) { + return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : undefined; + } + ts.tryRemoveSuffix = tryRemoveSuffix; + function stringContains(str, substring) { + return str.indexOf(substring) !== -1; + } + ts.stringContains = stringContains; + function removeMinAndVersionNumbers(fileName) { + var trailingMinOrVersion = /[.-]((min)|(\d+(\.\d+)*))$/; + return fileName.replace(trailingMinOrVersion, "").replace(trailingMinOrVersion, ""); + } + ts.removeMinAndVersionNumbers = removeMinAndVersionNumbers; + function orderedRemoveItem(array, item) { + for (var i = 0; i < array.length; i++) { + if (array[i] === item) { + orderedRemoveItemAt(array, i); + return true; + } + } + return false; + } + ts.orderedRemoveItem = orderedRemoveItem; + function orderedRemoveItemAt(array, index) { + for (var i = index; i < array.length - 1; i++) { + array[i] = array[i + 1]; + } + array.pop(); + } + ts.orderedRemoveItemAt = orderedRemoveItemAt; + function unorderedRemoveItemAt(array, index) { + array[index] = array[array.length - 1]; + array.pop(); + } + ts.unorderedRemoveItemAt = unorderedRemoveItemAt; + function unorderedRemoveItem(array, item) { + return unorderedRemoveFirstItemWhere(array, function (element) { return element === item; }); + } + ts.unorderedRemoveItem = unorderedRemoveItem; + function unorderedRemoveFirstItemWhere(array, predicate) { + for (var i = 0; i < array.length; i++) { + if (predicate(array[i])) { + unorderedRemoveItemAt(array, i); + return true; + } + } + return false; + } + function createGetCanonicalFileName(useCaseSensitiveFileNames) { + return useCaseSensitiveFileNames ? identity : toFileNameLowerCase; + } + ts.createGetCanonicalFileName = createGetCanonicalFileName; + function patternText(_a) { + var prefix = _a.prefix, suffix = _a.suffix; + return prefix + "*" + suffix; + } + ts.patternText = patternText; + function matchedText(pattern, candidate) { + ts.Debug.assert(isPatternMatch(pattern, candidate)); + return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length); + } + ts.matchedText = matchedText; + function findBestPatternMatch(values, getPattern, candidate) { + var matchedValue; + var longestMatchPrefixLength = -1; + for (var _i = 0, values_2 = values; _i < values_2.length; _i++) { + var v = values_2[_i]; + var pattern = getPattern(v); + if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) { + longestMatchPrefixLength = pattern.prefix.length; + matchedValue = v; + } + } + return matchedValue; + } + ts.findBestPatternMatch = findBestPatternMatch; + function startsWith(str, prefix) { + return str.lastIndexOf(prefix, 0) === 0; + } + ts.startsWith = startsWith; + function removePrefix(str, prefix) { + return startsWith(str, prefix) ? str.substr(prefix.length) : str; + } + ts.removePrefix = removePrefix; + function tryRemovePrefix(str, prefix, getCanonicalFileName) { + if (getCanonicalFileName === void 0) { getCanonicalFileName = identity; } + return startsWith(getCanonicalFileName(str), getCanonicalFileName(prefix)) ? str.substring(prefix.length) : undefined; + } + ts.tryRemovePrefix = tryRemovePrefix; + function isPatternMatch(_a, candidate) { + var prefix = _a.prefix, suffix = _a.suffix; + return candidate.length >= prefix.length + suffix.length && + startsWith(candidate, prefix) && + endsWith(candidate, suffix); + } + function and(f, g) { + return function (arg) { return f(arg) && g(arg); }; + } + ts.and = and; + function or() { + var fs = []; + for (var _i = 0; _i < arguments.length; _i++) { + fs[_i] = arguments[_i]; + } + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + for (var _a = 0, fs_1 = fs; _a < fs_1.length; _a++) { + var f = fs_1[_a]; + if (f.apply(void 0, args)) { + return true; + } + } + return false; + }; + } + ts.or = or; + function not(fn) { + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return !fn.apply(void 0, args); + }; + } + ts.not = not; + function assertType(_) { } + ts.assertType = assertType; + function singleElementArray(t) { + return t === undefined ? undefined : [t]; + } + ts.singleElementArray = singleElementArray; + function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) { + unchanged = unchanged || noop; + var newIndex = 0; + var oldIndex = 0; + var newLen = newItems.length; + var oldLen = oldItems.length; + while (newIndex < newLen && oldIndex < oldLen) { + var newItem = newItems[newIndex]; + var oldItem = oldItems[oldIndex]; + var compareResult = comparer(newItem, oldItem); + if (compareResult === -1) { + inserted(newItem); + newIndex++; + } + else if (compareResult === 1) { + deleted(oldItem); + oldIndex++; + } + else { + unchanged(oldItem, newItem); + newIndex++; + oldIndex++; + } + } + while (newIndex < newLen) { + inserted(newItems[newIndex++]); + } + while (oldIndex < oldLen) { + deleted(oldItems[oldIndex++]); + } + } + ts.enumerateInsertsAndDeletes = enumerateInsertsAndDeletes; + function fill(length, cb) { + var result = Array(length); + for (var i = 0; i < length; i++) { + result[i] = cb(i); + } + return result; + } + ts.fill = fill; + function cartesianProduct(arrays) { + var result = []; + cartesianProductWorker(arrays, result, undefined, 0); + return result; + } + ts.cartesianProduct = cartesianProduct; + function cartesianProductWorker(arrays, result, outer, index) { + for (var _i = 0, _a = arrays[index]; _i < _a.length; _i++) { + var element = _a[_i]; + var inner = void 0; + if (outer) { + inner = outer.slice(); + inner.push(element); + } + else { + inner = [element]; + } + if (index === arrays.length - 1) { + result.push(inner); + } + else { + cartesianProductWorker(arrays, result, inner, index + 1); + } + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var Debug; + (function (Debug) { + Debug.currentAssertionLevel = 0; + Debug.isDebugging = false; + function shouldAssert(level) { + return Debug.currentAssertionLevel >= level; + } + Debug.shouldAssert = shouldAssert; + function assert(expression, message, verboseDebugInfo, stackCrawlMark) { + if (!expression) { + if (verboseDebugInfo) { + message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo()); + } + fail(message ? "False expression: " + message : "False expression.", stackCrawlMark || assert); + } + } + Debug.assert = assert; + function assertEqual(a, b, msg, msg2) { + if (a !== b) { + var message = msg ? msg2 ? msg + " " + msg2 : msg : ""; + fail("Expected " + a + " === " + b + ". " + message); + } + } + Debug.assertEqual = assertEqual; + function assertLessThan(a, b, msg) { + if (a >= b) { + fail("Expected " + a + " < " + b + ". " + (msg || "")); + } + } + Debug.assertLessThan = assertLessThan; + function assertLessThanOrEqual(a, b) { + if (a > b) { + fail("Expected " + a + " <= " + b); + } + } + Debug.assertLessThanOrEqual = assertLessThanOrEqual; + function assertGreaterThanOrEqual(a, b) { + if (a < b) { + fail("Expected " + a + " >= " + b); + } + } + Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual; + function fail(message, stackCrawlMark) { + debugger; + var e = new Error(message ? "Debug Failure. " + message : "Debug Failure."); + if (Error.captureStackTrace) { + Error.captureStackTrace(e, stackCrawlMark || fail); + } + throw e; + } + Debug.fail = fail; + function assertDefined(value, message) { + if (value === undefined || value === null) + return fail(message); + return value; + } + Debug.assertDefined = assertDefined; + function assertEachDefined(value, message) { + for (var _i = 0, value_1 = value; _i < value_1.length; _i++) { + var v = value_1[_i]; + assertDefined(v, message); + } + return value; + } + Debug.assertEachDefined = assertEachDefined; + function assertNever(member, message, stackCrawlMark) { + if (message === void 0) { message = "Illegal value:"; } + var detail = typeof member === "object" && ts.hasProperty(member, "kind") && ts.hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member); + return fail(message + " " + detail, stackCrawlMark || assertNever); + } + Debug.assertNever = assertNever; + function getFunctionName(func) { + if (typeof func !== "function") { + return ""; + } + else if (func.hasOwnProperty("name")) { + return func.name; + } + else { + var text = Function.prototype.toString.call(func); + var match = /^function\s+([\w\$]+)\s*\(/.exec(text); + return match ? match[1] : ""; + } + } + Debug.getFunctionName = getFunctionName; + function formatSymbol(symbol) { + return "{ name: " + ts.unescapeLeadingUnderscores(symbol.escapedName) + "; flags: " + formatSymbolFlags(symbol.flags) + "; declarations: " + ts.map(symbol.declarations, function (node) { return formatSyntaxKind(node.kind); }) + " }"; + } + Debug.formatSymbol = formatSymbol; + function formatEnum(value, enumObject, isFlags) { + if (value === void 0) { value = 0; } + var members = getEnumMembers(enumObject); + if (value === 0) { + return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0"; + } + if (isFlags) { + var result = ""; + var remainingFlags = value; + for (var _i = 0, members_1 = members; _i < members_1.length; _i++) { + var _a = members_1[_i], enumValue = _a[0], enumName = _a[1]; + if (enumValue > value) { + break; + } + if (enumValue !== 0 && enumValue & value) { + result = "" + result + (result ? "|" : "") + enumName; + remainingFlags &= ~enumValue; + } + } + if (remainingFlags === 0) { + return result; + } + } + else { + for (var _b = 0, members_2 = members; _b < members_2.length; _b++) { + var _c = members_2[_b], enumValue = _c[0], enumName = _c[1]; + if (enumValue === value) { + return enumName; + } + } + } + return value.toString(); + } + Debug.formatEnum = formatEnum; + function getEnumMembers(enumObject) { + var result = []; + for (var name in enumObject) { + var value = enumObject[name]; + if (typeof value === "number") { + result.push([value, name]); + } + } + return ts.stableSort(result, function (x, y) { return ts.compareValues(x[0], y[0]); }); + } + function formatSyntaxKind(kind) { + return formatEnum(kind, ts.SyntaxKind, false); + } + Debug.formatSyntaxKind = formatSyntaxKind; + function formatNodeFlags(flags) { + return formatEnum(flags, ts.NodeFlags, true); + } + Debug.formatNodeFlags = formatNodeFlags; + function formatModifierFlags(flags) { + return formatEnum(flags, ts.ModifierFlags, true); + } + Debug.formatModifierFlags = formatModifierFlags; + function formatTransformFlags(flags) { + return formatEnum(flags, ts.TransformFlags, true); + } + Debug.formatTransformFlags = formatTransformFlags; + function formatEmitFlags(flags) { + return formatEnum(flags, ts.EmitFlags, true); + } + Debug.formatEmitFlags = formatEmitFlags; + function formatSymbolFlags(flags) { + return formatEnum(flags, ts.SymbolFlags, true); + } + Debug.formatSymbolFlags = formatSymbolFlags; + function formatTypeFlags(flags) { + return formatEnum(flags, ts.TypeFlags, true); + } + Debug.formatTypeFlags = formatTypeFlags; + function formatObjectFlags(flags) { + return formatEnum(flags, ts.ObjectFlags, true); + } + Debug.formatObjectFlags = formatObjectFlags; + function failBadSyntaxKind(node, message) { + return fail((message || "Unexpected node.") + "\r\nNode " + formatSyntaxKind(node.kind) + " was unexpected.", failBadSyntaxKind); + } + Debug.failBadSyntaxKind = failBadSyntaxKind; + Debug.assertEachNode = shouldAssert(1) + ? function (nodes, test, message) { return assert(test === undefined || ts.every(nodes, test), message || "Unexpected node.", function () { return "Node array did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertEachNode); } + : ts.noop; + Debug.assertNode = shouldAssert(1) + ? function (node, test, message) { return assert(test === undefined || test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertNode); } + : ts.noop; + Debug.assertNotNode = shouldAssert(1) + ? function (node, test, message) { return assert(test === undefined || !test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " should not have passed test '" + getFunctionName(test) + "'."; }, Debug.assertNode); } + : ts.noop; + Debug.assertOptionalNode = shouldAssert(1) + ? function (node, test, message) { return assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertOptionalNode); } + : ts.noop; + Debug.assertOptionalToken = shouldAssert(1) + ? function (node, kind, message) { return assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " was not a '" + formatSyntaxKind(kind) + "' token."; }, Debug.assertOptionalToken); } + : ts.noop; + Debug.assertMissingNode = shouldAssert(1) + ? function (node, message) { return assert(node === undefined, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " was unexpected'."; }, Debug.assertMissingNode); } + : ts.noop; + var isDebugInfoEnabled = false; + var extendedDebugModule; + function extendedDebug() { + enableDebugInfo(); + if (!extendedDebugModule) { + throw new Error("Debugging helpers could not be loaded."); + } + return extendedDebugModule; + } + function printControlFlowGraph(flowNode) { + return console.log(formatControlFlowGraph(flowNode)); + } + Debug.printControlFlowGraph = printControlFlowGraph; + function formatControlFlowGraph(flowNode) { + return extendedDebug().formatControlFlowGraph(flowNode); + } + Debug.formatControlFlowGraph = formatControlFlowGraph; + function attachFlowNodeDebugInfo(flowNode) { + if (isDebugInfoEnabled) { + if (!("__debugFlowFlags" in flowNode)) { + Object.defineProperties(flowNode, { + __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts.FlowFlags, true); } }, + __debugToString: { value: function () { return formatControlFlowGraph(this); } } + }); + } + } + } + Debug.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo; + function enableDebugInfo() { + if (isDebugInfoEnabled) + return; + Object.defineProperties(ts.objectAllocator.getSymbolConstructor().prototype, { + __debugFlags: { get: function () { return formatSymbolFlags(this.flags); } } + }); + Object.defineProperties(ts.objectAllocator.getTypeConstructor().prototype, { + __debugFlags: { get: function () { return formatTypeFlags(this.flags); } }, + __debugObjectFlags: { get: function () { return this.flags & 524288 ? formatObjectFlags(this.objectFlags) : ""; } }, + __debugTypeToString: { value: function () { return this.checker.typeToString(this); } }, + }); + var nodeConstructors = [ + ts.objectAllocator.getNodeConstructor(), + ts.objectAllocator.getIdentifierConstructor(), + ts.objectAllocator.getTokenConstructor(), + ts.objectAllocator.getSourceFileConstructor() + ]; + for (var _i = 0, nodeConstructors_1 = nodeConstructors; _i < nodeConstructors_1.length; _i++) { + var ctor = nodeConstructors_1[_i]; + if (!ctor.prototype.hasOwnProperty("__debugKind")) { + Object.defineProperties(ctor.prototype, { + __debugKind: { get: function () { return formatSyntaxKind(this.kind); } }, + __debugNodeFlags: { get: function () { return formatNodeFlags(this.flags); } }, + __debugModifierFlags: { get: function () { return formatModifierFlags(ts.getModifierFlagsNoCache(this)); } }, + __debugTransformFlags: { get: function () { return formatTransformFlags(this.transformFlags); } }, + __debugIsParseTreeNode: { get: function () { return ts.isParseTreeNode(this); } }, + __debugEmitFlags: { get: function () { return formatEmitFlags(ts.getEmitFlags(this)); } }, + __debugGetText: { + value: function (includeTrivia) { + if (ts.nodeIsSynthesized(this)) + return ""; + var parseNode = ts.getParseTreeNode(this); + var sourceFile = parseNode && ts.getSourceFileOfNode(parseNode); + return sourceFile ? ts.getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : ""; + } + } + }); + } + } + try { + if (ts.sys && ts.sys.require) { + var basePath = ts.getDirectoryPath(ts.resolvePath(ts.sys.getExecutingFilePath())); + var result = ts.sys.require(basePath, "./compiler-debug"); + if (!result.error) { + result.module.init(ts); + extendedDebugModule = result.module; + } + } + } + catch (_a) { + } + isDebugInfoEnabled = true; + } + Debug.enableDebugInfo = enableDebugInfo; + })(Debug = ts.Debug || (ts.Debug = {})); +})(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 () { }; + var enabled = false; + var profilerStart = 0; + var counts; + var marks; + var measures; + function createTimerIf(condition, measureName, startMarkName, endMarkName) { + return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer; + } + performance.createTimerIf = createTimerIf; + function createTimer(measureName, startMarkName, endMarkName) { + var enterCount = 0; + return { + enter: enter, + exit: exit + }; + function enter() { + if (++enterCount === 1) { + mark(startMarkName); + } + } + function exit() { + if (--enterCount === 0) { + mark(endMarkName); + measure(measureName, startMarkName, endMarkName); + } + else if (enterCount < 0) { + ts.Debug.fail("enter/exit count does not match."); + } + } + } + performance.createTimer = createTimer; + performance.nullTimer = { enter: ts.noop, exit: ts.noop }; + 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) { + var nullLogger = { + logEvent: ts.noop, + logErrEvent: ts.noop, + logPerfEvent: ts.noop, + logInfoEvent: ts.noop, + logStartCommand: ts.noop, + logStopCommand: ts.noop, + logStartUpdateProgram: ts.noop, + logStopUpdateProgram: ts.noop, + logStartUpdateGraph: ts.noop, + logStopUpdateGraph: ts.noop, + logStartResolveModule: ts.noop, + logStopResolveModule: ts.noop, + logStartParseSourceFile: ts.noop, + logStopParseSourceFile: ts.noop, + logStartReadFile: ts.noop, + logStopReadFile: ts.noop, + logStartBindFile: ts.noop, + logStopBindFile: ts.noop, + logStartScheduledOperation: ts.noop, + logStopScheduledOperation: ts.noop, + }; + var etwModule; + try { + etwModule = require("@microsoft/typescript-etw"); + } + catch (e) { + etwModule = undefined; + } + ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger; +})(ts || (ts = {})); +var ts; +(function (ts) { + var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; + var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i; + var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i; + var numericIdentifierRegExp = /^(0|[1-9]\d*)$/; + var Version = (function () { + function Version(major, minor, patch, prerelease, build) { + if (minor === void 0) { minor = 0; } + if (patch === void 0) { patch = 0; } + if (prerelease === void 0) { prerelease = ""; } + if (build === void 0) { build = ""; } + if (typeof major === "string") { + var result = ts.Debug.assertDefined(tryParseComponents(major), "Invalid version"); + (major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build); + } + ts.Debug.assert(major >= 0, "Invalid argument: major"); + ts.Debug.assert(minor >= 0, "Invalid argument: minor"); + ts.Debug.assert(patch >= 0, "Invalid argument: patch"); + ts.Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease"); + ts.Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build"); + this.major = major; + this.minor = minor; + this.patch = patch; + this.prerelease = prerelease ? prerelease.split(".") : ts.emptyArray; + this.build = build ? build.split(".") : ts.emptyArray; + } + Version.tryParse = function (text) { + var result = tryParseComponents(text); + if (!result) + return undefined; + var major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build; + return new Version(major, minor, patch, prerelease, build); + }; + Version.prototype.compareTo = function (other) { + if (this === other) + return 0; + if (other === undefined) + return 1; + return ts.compareValues(this.major, other.major) + || ts.compareValues(this.minor, other.minor) + || ts.compareValues(this.patch, other.patch) + || comparePrerelaseIdentifiers(this.prerelease, other.prerelease); + }; + Version.prototype.increment = function (field) { + switch (field) { + case "major": return new Version(this.major + 1, 0, 0); + case "minor": return new Version(this.major, this.minor + 1, 0); + case "patch": return new Version(this.major, this.minor, this.patch + 1); + default: return ts.Debug.assertNever(field); + } + }; + Version.prototype.toString = function () { + var result = this.major + "." + this.minor + "." + this.patch; + if (ts.some(this.prerelease)) + result += "-" + this.prerelease.join("."); + if (ts.some(this.build)) + result += "+" + this.build.join("."); + return result; + }; + Version.zero = new Version(0, 0, 0); + return Version; + }()); + ts.Version = Version; + function tryParseComponents(text) { + var match = versionRegExp.exec(text); + if (!match) + return undefined; + var major = match[1], _a = match[2], minor = _a === void 0 ? "0" : _a, _b = match[3], patch = _b === void 0 ? "0" : _b, _c = match[4], prerelease = _c === void 0 ? "" : _c, _d = match[5], build = _d === void 0 ? "" : _d; + if (prerelease && !prereleaseRegExp.test(prerelease)) + return undefined; + if (build && !buildRegExp.test(build)) + return undefined; + return { + major: parseInt(major, 10), + minor: parseInt(minor, 10), + patch: parseInt(patch, 10), + prerelease: prerelease, + build: build + }; + } + function comparePrerelaseIdentifiers(left, right) { + if (left === right) + return 0; + if (left.length === 0) + return right.length === 0 ? 0 : 1; + if (right.length === 0) + return -1; + var length = Math.min(left.length, right.length); + for (var i = 0; i < length; i++) { + var leftIdentifier = left[i]; + var rightIdentifier = right[i]; + if (leftIdentifier === rightIdentifier) + continue; + var leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier); + var rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier); + if (leftIsNumeric || rightIsNumeric) { + if (leftIsNumeric !== rightIsNumeric) + return leftIsNumeric ? -1 : 1; + var result = ts.compareValues(+leftIdentifier, +rightIdentifier); + if (result) + return result; + } + else { + var result = ts.compareStringsCaseSensitive(leftIdentifier, rightIdentifier); + if (result) + return result; + } + } + return ts.compareValues(left.length, right.length); + } + var VersionRange = (function () { + function VersionRange(spec) { + this._alternatives = spec ? ts.Debug.assertDefined(parseRange(spec), "Invalid range spec.") : ts.emptyArray; + } + VersionRange.tryParse = function (text) { + var sets = parseRange(text); + if (sets) { + var range = new VersionRange(""); + range._alternatives = sets; + return range; + } + return undefined; + }; + VersionRange.prototype.test = function (version) { + if (typeof version === "string") + version = new Version(version); + return testDisjunction(version, this._alternatives); + }; + VersionRange.prototype.toString = function () { + return formatDisjunction(this._alternatives); + }; + return VersionRange; + }()); + ts.VersionRange = VersionRange; + var logicalOrRegExp = /\s*\|\|\s*/g; + var whitespaceRegExp = /\s+/g; + var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; + var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i; + var rangeRegExp = /^\s*(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i; + function parseRange(text) { + var alternatives = []; + for (var _i = 0, _a = text.trim().split(logicalOrRegExp); _i < _a.length; _i++) { + var range = _a[_i]; + if (!range) + continue; + var comparators = []; + var match = hyphenRegExp.exec(range); + if (match) { + if (!parseHyphen(match[1], match[2], comparators)) + return undefined; + } + else { + for (var _b = 0, _c = range.split(whitespaceRegExp); _b < _c.length; _b++) { + var simple = _c[_b]; + var match_1 = rangeRegExp.exec(simple); + if (!match_1 || !parseComparator(match_1[1], match_1[2], comparators)) + return undefined; + } + } + alternatives.push(comparators); + } + return alternatives; + } + function parsePartial(text) { + var match = partialRegExp.exec(text); + if (!match) + return undefined; + var major = match[1], _a = match[2], minor = _a === void 0 ? "*" : _a, _b = match[3], patch = _b === void 0 ? "*" : _b, prerelease = match[4], build = match[5]; + var version = new Version(isWildcard(major) ? 0 : parseInt(major, 10), isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10), isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10), prerelease, build); + return { version: version, major: major, minor: minor, patch: patch }; + } + function parseHyphen(left, right, comparators) { + var leftResult = parsePartial(left); + if (!leftResult) + return false; + var rightResult = parsePartial(right); + if (!rightResult) + return false; + if (!isWildcard(leftResult.major)) { + comparators.push(createComparator(">=", leftResult.version)); + } + if (!isWildcard(rightResult.major)) { + comparators.push(isWildcard(rightResult.minor) ? createComparator("<", rightResult.version.increment("major")) : + isWildcard(rightResult.patch) ? createComparator("<", rightResult.version.increment("minor")) : + createComparator("<=", rightResult.version)); + } + return true; + } + function parseComparator(operator, text, comparators) { + var result = parsePartial(text); + if (!result) + return false; + var version = result.version, major = result.major, minor = result.minor, patch = result.patch; + if (!isWildcard(major)) { + switch (operator) { + case "~": + comparators.push(createComparator(">=", version)); + comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : + "minor"))); + break; + case "^": + comparators.push(createComparator(">=", version)); + comparators.push(createComparator("<", version.increment(version.major > 0 || isWildcard(minor) ? "major" : + version.minor > 0 || isWildcard(patch) ? "minor" : + "patch"))); + break; + case "<": + case ">=": + comparators.push(createComparator(operator, version)); + break; + case "<=": + case ">": + comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) : + isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) : + createComparator(operator, version)); + break; + case "=": + case undefined: + if (isWildcard(minor) || isWildcard(patch)) { + comparators.push(createComparator(">=", version)); + comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor"))); + } + else { + comparators.push(createComparator("=", version)); + } + break; + default: + return false; + } + } + else if (operator === "<" || operator === ">") { + comparators.push(createComparator("<", Version.zero)); + } + return true; + } + function isWildcard(part) { + return part === "*" || part === "x" || part === "X"; + } + function createComparator(operator, operand) { + return { operator: operator, operand: operand }; + } + function testDisjunction(version, alternatives) { + if (alternatives.length === 0) + return true; + for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) { + var alternative = alternatives_1[_i]; + if (testAlternative(version, alternative)) + return true; + } + return false; + } + function testAlternative(version, comparators) { + for (var _i = 0, comparators_1 = comparators; _i < comparators_1.length; _i++) { + var comparator = comparators_1[_i]; + if (!testComparator(version, comparator.operator, comparator.operand)) + return false; + } + return true; + } + function testComparator(version, operator, operand) { + var cmp = version.compareTo(operand); + switch (operator) { + case "<": return cmp < 0; + case "<=": return cmp <= 0; + case ">": return cmp > 0; + case ">=": return cmp >= 0; + case "=": return cmp === 0; + default: return ts.Debug.assertNever(operator); + } + } + function formatDisjunction(alternatives) { + return ts.map(alternatives, formatAlternative).join(" || ") || "*"; + } + function formatAlternative(comparators) { + return ts.map(comparators, formatComparator).join(" "); + } + function formatComparator(comparator) { + return "" + comparator.operator + comparator.operand; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var OperationCanceledException = (function () { + function OperationCanceledException() { + } + return OperationCanceledException; + }()); + ts.OperationCanceledException = OperationCanceledException; + var RefFileKind; + (function (RefFileKind) { + RefFileKind[RefFileKind["Import"] = 0] = "Import"; + RefFileKind[RefFileKind["ReferenceFile"] = 1] = "ReferenceFile"; + RefFileKind[RefFileKind["TypeReferenceDirective"] = 2] = "TypeReferenceDirective"; + })(RefFileKind = ts.RefFileKind || (ts.RefFileKind = {})); + var ExitStatus; + (function (ExitStatus) { + ExitStatus[ExitStatus["Success"] = 0] = "Success"; + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped"; + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated"; + ExitStatus[ExitStatus["InvalidProject_OutputsSkipped"] = 3] = "InvalidProject_OutputsSkipped"; + ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkipped"] = 4] = "ProjectReferenceCycle_OutputsSkipped"; + ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped"; + })(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["BigIntLikeType"] = 4] = "BigIntLikeType"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 5] = "StringLikeType"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 6] = "BooleanType"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 7] = "ArrayLikeType"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 8] = "ESSymbolType"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["Promise"] = 9] = "Promise"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 10] = "TypeWithCallSignature"; + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 11] = "ObjectType"; + })(TypeReferenceSerializationKind = ts.TypeReferenceSerializationKind || (ts.TypeReferenceSerializationKind = {})); + var DiagnosticCategory; + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion"; + DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message"; + })(DiagnosticCategory = ts.DiagnosticCategory || (ts.DiagnosticCategory = {})); + function diagnosticCategoryName(d, lowerCase) { + if (lowerCase === void 0) { lowerCase = true; } + var name = DiagnosticCategory[d.category]; + return lowerCase ? name.toLowerCase() : name; + } + ts.diagnosticCategoryName = diagnosticCategoryName; + var ModuleResolutionKind; + (function (ModuleResolutionKind) { + ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic"; + ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs"; + })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {})); + var WatchFileKind; + (function (WatchFileKind) { + WatchFileKind[WatchFileKind["FixedPollingInterval"] = 0] = "FixedPollingInterval"; + WatchFileKind[WatchFileKind["PriorityPollingInterval"] = 1] = "PriorityPollingInterval"; + WatchFileKind[WatchFileKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + WatchFileKind[WatchFileKind["UseFsEvents"] = 3] = "UseFsEvents"; + WatchFileKind[WatchFileKind["UseFsEventsOnParentDirectory"] = 4] = "UseFsEventsOnParentDirectory"; + })(WatchFileKind = ts.WatchFileKind || (ts.WatchFileKind = {})); + var WatchDirectoryKind; + (function (WatchDirectoryKind) { + WatchDirectoryKind[WatchDirectoryKind["UseFsEvents"] = 0] = "UseFsEvents"; + WatchDirectoryKind[WatchDirectoryKind["FixedPollingInterval"] = 1] = "FixedPollingInterval"; + WatchDirectoryKind[WatchDirectoryKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + })(WatchDirectoryKind = ts.WatchDirectoryKind || (ts.WatchDirectoryKind = {})); + var PollingWatchKind; + (function (PollingWatchKind) { + PollingWatchKind[PollingWatchKind["FixedInterval"] = 0] = "FixedInterval"; + PollingWatchKind[PollingWatchKind["PriorityInterval"] = 1] = "PriorityInterval"; + PollingWatchKind[PollingWatchKind["DynamicPriority"] = 2] = "DynamicPriority"; + })(PollingWatchKind = ts.PollingWatchKind || (ts.PollingWatchKind = {})); + 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["ES2020"] = 6] = "ES2020"; + ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext"; + })(ModuleKind = ts.ModuleKind || (ts.ModuleKind = {})); + ts.commentPragmas = { + "reference": { + args: [ + { name: "types", optional: true, captureSpan: true }, + { name: "lib", optional: true, captureSpan: true }, + { name: "path", optional: true, captureSpan: true }, + { name: "no-default-lib", optional: true } + ], + kind: 1 + }, + "amd-dependency": { + args: [{ name: "path" }, { name: "name", optional: true }], + kind: 1 + }, + "amd-module": { + args: [{ name: "name" }], + kind: 1 + }, + "ts-check": { + kind: 2 + }, + "ts-nocheck": { + kind: 2 + }, + "jsx": { + args: [{ name: "factory" }], + kind: 4 + }, + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function generateDjb2Hash(data) { + var acc = 5381; + for (var i = 0; i < data.length; i++) { + acc = ((acc << 5) + acc) + data.charCodeAt(i); + } + return acc.toString(); + } + ts.generateDjb2Hash = generateDjb2Hash; + function setStackTraceLimit() { + if (Error.stackTraceLimit < 100) { + Error.stackTraceLimit = 100; + } + } + ts.setStackTraceLimit = setStackTraceLimit; + var FileWatcherEventKind; + (function (FileWatcherEventKind) { + FileWatcherEventKind[FileWatcherEventKind["Created"] = 0] = "Created"; + FileWatcherEventKind[FileWatcherEventKind["Changed"] = 1] = "Changed"; + FileWatcherEventKind[FileWatcherEventKind["Deleted"] = 2] = "Deleted"; + })(FileWatcherEventKind = ts.FileWatcherEventKind || (ts.FileWatcherEventKind = {})); + var PollingInterval; + (function (PollingInterval) { + PollingInterval[PollingInterval["High"] = 2000] = "High"; + PollingInterval[PollingInterval["Medium"] = 500] = "Medium"; + PollingInterval[PollingInterval["Low"] = 250] = "Low"; + })(PollingInterval = ts.PollingInterval || (ts.PollingInterval = {})); + ts.missingFileModifiedTime = new Date(0); + function createPollingIntervalBasedLevels(levels) { + var _a; + return _a = {}, + _a[PollingInterval.Low] = levels.Low, + _a[PollingInterval.Medium] = levels.Medium, + _a[PollingInterval.High] = levels.High, + _a; + } + var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 }; + var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels); + ts.unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels); + function setCustomPollingValues(system) { + if (!system.getEnvironmentVariable) { + return; + } + var pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval); + pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize; + ts.unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || ts.unchangedPollThresholds; + function getLevel(envVar, level) { + return system.getEnvironmentVariable(envVar + "_" + level.toUpperCase()); + } + function getCustomLevels(baseVariable) { + var customLevels; + setCustomLevel("Low"); + setCustomLevel("Medium"); + setCustomLevel("High"); + return customLevels; + function setCustomLevel(level) { + var customLevel = getLevel(baseVariable, level); + if (customLevel) { + (customLevels || (customLevels = {}))[level] = Number(customLevel); + } + } + } + function setCustomLevels(baseVariable, levels) { + var customLevels = getCustomLevels(baseVariable); + if (customLevels) { + setLevel("Low"); + setLevel("Medium"); + setLevel("High"); + return true; + } + return false; + function setLevel(level) { + levels[level] = customLevels[level] || levels[level]; + } + } + function getCustomPollingBasedLevels(baseVariable, defaultLevels) { + var customLevels = getCustomLevels(baseVariable); + return (pollingIntervalChanged || customLevels) && + createPollingIntervalBasedLevels(customLevels ? __assign(__assign({}, defaultLevels), customLevels) : defaultLevels); + } + } + ts.setCustomPollingValues = setCustomPollingValues; + function createDynamicPriorityPollingWatchFile(host) { + var watchedFiles = []; + var changedFilesInLastPoll = []; + var lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low); + var mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium); + var highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High); + return watchFile; + function watchFile(fileName, callback, defaultPollingInterval) { + var file = { + fileName: fileName, + callback: callback, + unchangedPolls: 0, + mtime: getModifiedTime(fileName) + }; + watchedFiles.push(file); + addToPollingIntervalQueue(file, defaultPollingInterval); + return { + close: function () { + file.isClosed = true; + ts.unorderedRemoveItem(watchedFiles, file); + } + }; + } + function createPollingIntervalQueue(pollingInterval) { + var queue = []; + queue.pollingInterval = pollingInterval; + queue.pollIndex = 0; + queue.pollScheduled = false; + return queue; + } + function pollPollingIntervalQueue(queue) { + queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]); + if (queue.length) { + scheduleNextPoll(queue.pollingInterval); + } + else { + ts.Debug.assert(queue.pollIndex === 0); + queue.pollScheduled = false; + } + } + function pollLowPollingIntervalQueue(queue) { + pollQueue(changedFilesInLastPoll, PollingInterval.Low, 0, changedFilesInLastPoll.length); + pollPollingIntervalQueue(queue); + if (!queue.pollScheduled && changedFilesInLastPoll.length) { + scheduleNextPoll(PollingInterval.Low); + } + } + function pollQueue(queue, pollingInterval, pollIndex, chunkSize) { + var needsVisit = queue.length; + var definedValueCopyToIndex = pollIndex; + for (var polled = 0; polled < chunkSize && needsVisit > 0; nextPollIndex(), needsVisit--) { + var watchedFile = queue[pollIndex]; + if (!watchedFile) { + continue; + } + else if (watchedFile.isClosed) { + queue[pollIndex] = undefined; + continue; + } + polled++; + var fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(watchedFile.fileName)); + if (watchedFile.isClosed) { + queue[pollIndex] = undefined; + } + else if (fileChanged) { + watchedFile.unchangedPolls = 0; + if (queue !== changedFilesInLastPoll) { + queue[pollIndex] = undefined; + addChangedFileToLowPollingIntervalQueue(watchedFile); + } + } + else if (watchedFile.unchangedPolls !== ts.unchangedPollThresholds[pollingInterval]) { + watchedFile.unchangedPolls++; + } + else if (queue === changedFilesInLastPoll) { + 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); + } + if (queue[pollIndex]) { + if (definedValueCopyToIndex < pollIndex) { + queue[definedValueCopyToIndex] = watchedFile; + queue[pollIndex] = undefined; + } + definedValueCopyToIndex++; + } + } + return pollIndex; + function nextPollIndex() { + pollIndex++; + if (pollIndex === queue.length) { + if (definedValueCopyToIndex < pollIndex) { + queue.length = definedValueCopyToIndex; + } + pollIndex = 0; + definedValueCopyToIndex = 0; + } + } + } + function pollingIntervalQueue(pollingInterval) { + switch (pollingInterval) { + case PollingInterval.Low: + return lowPollingIntervalQueue; + case PollingInterval.Medium: + return mediumPollingIntervalQueue; + case PollingInterval.High: + return highPollingIntervalQueue; + } + } + function addToPollingIntervalQueue(file, pollingInterval) { + pollingIntervalQueue(pollingInterval).push(file); + scheduleNextPollIfNotAlreadyScheduled(pollingInterval); + } + function addChangedFileToLowPollingIntervalQueue(file) { + changedFilesInLastPoll.push(file); + scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low); + } + function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) { + if (!pollingIntervalQueue(pollingInterval).pollScheduled) { + scheduleNextPoll(pollingInterval); + } + } + function scheduleNextPoll(pollingInterval) { + pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval)); + } + function getModifiedTime(fileName) { + return host.getModifiedTime(fileName) || ts.missingFileModifiedTime; + } + } + ts.createDynamicPriorityPollingWatchFile = createDynamicPriorityPollingWatchFile; + function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) { + var fileWatcherCallbacks = ts.createMultiMap(); + var dirWatchers = ts.createMap(); + var toCanonicalName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return nonPollingWatchFile; + function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) { + var filePath = toCanonicalName(fileName); + fileWatcherCallbacks.add(filePath, callback); + var dirPath = ts.getDirectoryPath(filePath) || "."; + var watcher = dirWatchers.get(dirPath) || + createDirectoryWatcher(ts.getDirectoryPath(fileName) || ".", dirPath, fallbackOptions); + watcher.referenceCount++; + return { + close: function () { + if (watcher.referenceCount === 1) { + watcher.close(); + dirWatchers.delete(dirPath); + } + else { + watcher.referenceCount--; + } + fileWatcherCallbacks.remove(filePath, callback); + } + }; + } + function createDirectoryWatcher(dirName, dirPath, fallbackOptions) { + var watcher = fsWatch(dirName, 1, function (_eventName, relativeFileName) { + if (!ts.isString(relativeFileName)) { + return; + } + var fileName = ts.getNormalizedAbsolutePath(relativeFileName, dirName); + var callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName)); + if (callbacks) { + for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) { + var fileCallback = callbacks_1[_i]; + fileCallback(fileName, FileWatcherEventKind.Changed); + } + } + }, false, PollingInterval.Medium, fallbackOptions); + watcher.referenceCount = 0; + dirWatchers.set(dirPath, watcher); + return watcher; + } + } + function createSingleFileWatcherPerName(watchFile, useCaseSensitiveFileNames) { + var cache = ts.createMap(); + var callbacksCache = ts.createMultiMap(); + var toCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return function (fileName, callback, pollingInterval, options) { + var path = toCanonicalFileName(fileName); + var existing = cache.get(path); + if (existing) { + existing.refCount++; + } + else { + cache.set(path, { + watcher: watchFile(fileName, function (fileName, eventKind) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind); }); }, pollingInterval, options), + refCount: 1 + }); + } + callbacksCache.add(path, callback); + return { + close: function () { + var watcher = ts.Debug.assertDefined(cache.get(path)); + callbacksCache.remove(path, callback); + watcher.refCount--; + if (watcher.refCount) + return; + cache.delete(path); + ts.closeFileWatcherOf(watcher); + } + }; + }; + } + ts.createSingleFileWatcherPerName = createSingleFileWatcherPerName; + function onWatchedFileStat(watchedFile, modifiedTime) { + var oldTime = watchedFile.mtime.getTime(); + var newTime = modifiedTime.getTime(); + if (oldTime !== newTime) { + watchedFile.mtime = modifiedTime; + watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime)); + return true; + } + return false; + } + ts.onWatchedFileStat = onWatchedFileStat; + function getFileWatcherEventKind(oldTime, newTime) { + return oldTime === 0 + ? FileWatcherEventKind.Created + : newTime === 0 + ? FileWatcherEventKind.Deleted + : FileWatcherEventKind.Changed; + } + ts.getFileWatcherEventKind = getFileWatcherEventKind; + ts.ignoredPaths = ["/node_modules/.", "/.git", "/.#"]; + ts.sysLog = ts.noop; + function setSysLog(logger) { + ts.sysLog = logger; + } + ts.setSysLog = setSysLog; + function createDirectoryWatcherSupportingRecursive(host) { + var cache = ts.createMap(); + var callbackCache = ts.createMultiMap(); + var cacheToUpdateChildWatches = ts.createMap(); + var timerToUpdateChildWatches; + var filePathComparer = ts.getStringComparer(!host.useCaseSensitiveFileNames); + var toCanonicalFilePath = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + return function (dirName, callback, recursive, options) { return recursive ? + createDirectoryWatcher(dirName, options, callback) : + host.watchDirectory(dirName, callback, recursive, options); }; + function createDirectoryWatcher(dirName, options, callback) { + var dirPath = toCanonicalFilePath(dirName); + var directoryWatcher = cache.get(dirPath); + if (directoryWatcher) { + directoryWatcher.refCount++; + } + else { + directoryWatcher = { + watcher: host.watchDirectory(dirName, function (fileName) { + if (isIgnoredPath(fileName)) + return; + if (options === null || options === void 0 ? void 0 : options.synchronousWatchDirectory) { + invokeCallbacks(dirPath, fileName); + updateChildWatches(dirName, dirPath, options); + } + else { + nonSyncUpdateChildWatches(dirName, dirPath, fileName, options); + } + }, false, options), + refCount: 1, + childWatches: ts.emptyArray + }; + cache.set(dirPath, directoryWatcher); + updateChildWatches(dirName, dirPath, options); + } + var callbackToAdd = callback && { dirName: dirName, callback: callback }; + if (callbackToAdd) { + callbackCache.add(dirPath, callbackToAdd); + } + return { + dirName: dirName, + close: function () { + var directoryWatcher = ts.Debug.assertDefined(cache.get(dirPath)); + if (callbackToAdd) + callbackCache.remove(dirPath, callbackToAdd); + directoryWatcher.refCount--; + if (directoryWatcher.refCount) + return; + cache.delete(dirPath); + ts.closeFileWatcherOf(directoryWatcher); + directoryWatcher.childWatches.forEach(ts.closeFileWatcher); + } + }; + } + function invokeCallbacks(dirPath, fileNameOrInvokeMap) { + var fileName; + var invokeMap; + if (ts.isString(fileNameOrInvokeMap)) { + fileName = fileNameOrInvokeMap; + } + else { + invokeMap = fileNameOrInvokeMap; + } + callbackCache.forEach(function (callbacks, rootDirName) { + if (invokeMap && invokeMap.has(rootDirName)) + return; + if (rootDirName === dirPath || (ts.startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === ts.directorySeparator)) { + if (invokeMap) { + invokeMap.set(rootDirName, true); + } + else { + callbacks.forEach(function (_a) { + var callback = _a.callback; + return callback(fileName); + }); + } + } + }); + } + function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) { + var parentWatcher = cache.get(dirPath); + if (parentWatcher && host.directoryExists(dirName)) { + scheduleUpdateChildWatches(dirName, dirPath, options); + return; + } + invokeCallbacks(dirPath, fileName); + removeChildWatches(parentWatcher); + } + function scheduleUpdateChildWatches(dirName, dirPath, options) { + if (!cacheToUpdateChildWatches.has(dirPath)) { + cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options }); + } + if (timerToUpdateChildWatches) { + host.clearTimeout(timerToUpdateChildWatches); + timerToUpdateChildWatches = undefined; + } + timerToUpdateChildWatches = host.setTimeout(onTimerToUpdateChildWatches, 1000); + } + function onTimerToUpdateChildWatches() { + timerToUpdateChildWatches = undefined; + ts.sysLog("sysLog:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size); + var start = ts.timestamp(); + var invokeMap = ts.createMap(); + while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) { + var _a = cacheToUpdateChildWatches.entries().next(), _b = _a.value, dirPath = _b[0], _c = _b[1], dirName = _c.dirName, options = _c.options, done = _a.done; + ts.Debug.assert(!done); + cacheToUpdateChildWatches.delete(dirPath); + invokeCallbacks(dirPath, invokeMap); + updateChildWatches(dirName, dirPath, options); + } + ts.sysLog("sysLog:: invokingWatchers:: " + (ts.timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size); + callbackCache.forEach(function (callbacks, rootDirName) { + if (invokeMap.has(rootDirName)) { + callbacks.forEach(function (_a) { + var callback = _a.callback, dirName = _a.dirName; + return callback(dirName); + }); + } + }); + var elapsed = ts.timestamp() - start; + ts.sysLog("sysLog:: Elapsed " + elapsed + "ms:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size + " " + timerToUpdateChildWatches); + } + function removeChildWatches(parentWatcher) { + if (!parentWatcher) + return; + var existingChildWatches = parentWatcher.childWatches; + parentWatcher.childWatches = ts.emptyArray; + for (var _i = 0, existingChildWatches_1 = existingChildWatches; _i < existingChildWatches_1.length; _i++) { + var childWatcher = existingChildWatches_1[_i]; + childWatcher.close(); + removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName))); + } + } + function updateChildWatches(dirName, dirPath, options) { + var parentWatcher = cache.get(dirPath); + if (parentWatcher) { + parentWatcher.childWatches = watchChildDirectories(dirName, parentWatcher.childWatches, options); + } + } + function watchChildDirectories(parentDir, existingChildWatches, options) { + var newChildWatches; + ts.enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts.mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) { + var childFullName = ts.getNormalizedAbsolutePath(child, parentDir); + return !isIgnoredPath(childFullName) && filePathComparer(childFullName, ts.normalizePath(host.realpath(childFullName))) === 0 ? childFullName : undefined; + }) : ts.emptyArray, existingChildWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher); + return newChildWatches || ts.emptyArray; + function createAndAddChildDirectoryWatcher(childName) { + var result = createDirectoryWatcher(childName, options); + addChildDirectoryWatcher(result); + } + function addChildDirectoryWatcher(childWatcher) { + (newChildWatches || (newChildWatches = [])).push(childWatcher); + } + } + function isIgnoredPath(path) { + return ts.some(ts.ignoredPaths, function (searchPath) { return isInPath(path, searchPath); }); + } + function isInPath(path, searchPath) { + if (ts.stringContains(path, searchPath)) + return true; + if (host.useCaseSensitiveFileNames) + return false; + return ts.stringContains(toCanonicalFilePath(path), searchPath); + } + } + ts.createDirectoryWatcherSupportingRecursive = createDirectoryWatcherSupportingRecursive; + function createFileWatcherCallback(callback) { + return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); }; + } + ts.createFileWatcherCallback = createFileWatcherCallback; + function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) { + return function (eventName) { + if (eventName === "rename") { + callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted); + } + else { + callback(fileName, FileWatcherEventKind.Changed); + } + }; + } + function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback) { + return function (eventName, relativeFileName) { + if (eventName === "rename") { + callback(!relativeFileName ? directoryName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName))); + } + }; + } + function createSystemWatchFunctions(_a) { + var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory; + var dynamicPollingWatchFile; + var nonPollingWatchFile; + var hostRecursiveDirectoryWatcher; + return { + watchFile: watchFile, + watchDirectory: watchDirectory + }; + function watchFile(fileName, callback, pollingInterval, options) { + options = updateOptionsForWatchFile(options, useNonPollingWatchers); + var watchFileKind = ts.Debug.assertDefined(options.watchFile); + switch (watchFileKind) { + case ts.WatchFileKind.FixedPollingInterval: + return pollingWatchFile(fileName, callback, PollingInterval.Low, undefined); + case ts.WatchFileKind.PriorityPollingInterval: + return pollingWatchFile(fileName, callback, pollingInterval, undefined); + case ts.WatchFileKind.DynamicPriorityPolling: + return ensureDynamicPollingWatchFile()(fileName, callback, pollingInterval, undefined); + case ts.WatchFileKind.UseFsEvents: + return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), false, pollingInterval, ts.getFallbackOptions(options)); + case ts.WatchFileKind.UseFsEventsOnParentDirectory: + if (!nonPollingWatchFile) { + nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames); + } + return nonPollingWatchFile(fileName, callback, pollingInterval, ts.getFallbackOptions(options)); + default: + ts.Debug.assertNever(watchFileKind); + } + } + function ensureDynamicPollingWatchFile() { + return dynamicPollingWatchFile || + (dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout })); + } + function updateOptionsForWatchFile(options, useNonPollingWatchers) { + if (options && options.watchFile !== undefined) + return options; + switch (tscWatchFile) { + case "PriorityPollingInterval": + return { watchFile: ts.WatchFileKind.PriorityPollingInterval }; + case "DynamicPriorityPolling": + return { watchFile: ts.WatchFileKind.DynamicPriorityPolling }; + case "UseFsEvents": + return generateWatchFileOptions(ts.WatchFileKind.UseFsEvents, ts.PollingWatchKind.PriorityInterval, options); + case "UseFsEventsWithFallbackDynamicPolling": + return generateWatchFileOptions(ts.WatchFileKind.UseFsEvents, ts.PollingWatchKind.DynamicPriority, options); + case "UseFsEventsOnParentDirectory": + useNonPollingWatchers = true; + default: + return useNonPollingWatchers ? + generateWatchFileOptions(ts.WatchFileKind.UseFsEventsOnParentDirectory, ts.PollingWatchKind.PriorityInterval, options) : + { watchFile: ts.WatchFileKind.FixedPollingInterval }; + } + } + function generateWatchFileOptions(watchFile, fallbackPolling, options) { + var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchFile: watchFile, + fallbackPolling: defaultFallbackPolling === undefined ? + fallbackPolling : + defaultFallbackPolling + }; + } + function watchDirectory(directoryName, callback, recursive, options) { + if (fsSupportsRecursiveFsWatch) { + return fsWatch(directoryName, 1, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); + } + if (!hostRecursiveDirectoryWatcher) { + hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({ + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + directoryExists: directoryExists, + getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories, + watchDirectory: nonRecursiveWatchDirectory, + realpath: realpath, + setTimeout: setTimeout, + clearTimeout: clearTimeout + }); + } + return hostRecursiveDirectoryWatcher(directoryName, callback, recursive, options); + } + function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) { + ts.Debug.assert(!recursive); + options = updateOptionsForWatchDirectory(options); + var watchDirectoryKind = ts.Debug.assertDefined(options.watchDirectory); + switch (watchDirectoryKind) { + case ts.WatchDirectoryKind.FixedPollingInterval: + return pollingWatchFile(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, undefined); + case ts.WatchDirectoryKind.DynamicPriorityPolling: + return ensureDynamicPollingWatchFile()(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, undefined); + case ts.WatchDirectoryKind.UseFsEvents: + return fsWatch(directoryName, 1, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); + default: + ts.Debug.assertNever(watchDirectoryKind); + } + } + function updateOptionsForWatchDirectory(options) { + if (options && options.watchDirectory !== undefined) + return options; + switch (tscWatchDirectory) { + case "RecursiveDirectoryUsingFsWatchFile": + return { watchDirectory: ts.WatchDirectoryKind.FixedPollingInterval }; + case "RecursiveDirectoryUsingDynamicPriorityPolling": + return { watchDirectory: ts.WatchDirectoryKind.DynamicPriorityPolling }; + default: + var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchDirectory: ts.WatchDirectoryKind.UseFsEvents, + fallbackPolling: defaultFallbackPolling !== undefined ? + defaultFallbackPolling : + undefined + }; + } + } + } + ts.createSystemWatchFunctions = createSystemWatchFunctions; + function patchWriteFileEnsuringDirectory(sys) { + var originalWriteFile = sys.writeFile; + sys.writeFile = function (path, data, writeBom) { + return ts.writeFileEnsuringDirectories(path, data, !!writeBom, function (path, data, writeByteOrderMark) { return originalWriteFile.call(sys, path, data, writeByteOrderMark); }, function (path) { return sys.createDirectory(path); }, function (path) { return sys.directoryExists(path); }); + }; + } + ts.patchWriteFileEnsuringDirectory = patchWriteFileEnsuringDirectory; + function getNodeMajorVersion() { + if (typeof process === "undefined") { + return undefined; + } + var version = process.version; + if (!version) { + return undefined; + } + var dot = version.indexOf("."); + if (dot === -1) { + return undefined; + } + return parseInt(version.substring(1, dot)); + } + ts.getNodeMajorVersion = getNodeMajorVersion; + ts.sys = (function () { + var byteOrderMarkIndicator = "\uFEFF"; + function getNodeSystem() { + var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/; + var _fs = require("fs"); + var _path = require("path"); + var _os = require("os"); + var _crypto; + try { + _crypto = require("crypto"); + } + catch (_a) { + _crypto = undefined; + } + var activeSession; + var profilePath = "./profile.cpuprofile"; + var Buffer = require("buffer").Buffer; + var nodeVersion = getNodeMajorVersion(); + var isNode4OrLater = nodeVersion >= 4; + var isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin"; + var platform = _os.platform(); + var useCaseSensitiveFileNames = isFileSystemCaseSensitive(); + var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin"); + var _b = createSystemWatchFunctions({ + pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames), + getModifiedTime: getModifiedTime, + setTimeout: setTimeout, + clearTimeout: clearTimeout, + fsWatch: fsWatch, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + fileExists: fileExists, + fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch, + directoryExists: directoryExists, + getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; }, + realpath: realpath, + tscWatchFile: process.env.TSC_WATCHFILE, + useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER, + tscWatchDirectory: process.env.TSC_WATCHDIRECTORY, + }), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory; + var nodeSystem = { + args: process.argv.slice(2), + newLine: _os.EOL, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + write: function (s) { + process.stdout.write(s); + }, + writeOutputIsTTY: function () { + return process.stdout.isTTY; + }, + readFile: readFile, + writeFile: writeFile, + watchFile: watchFile, + watchDirectory: watchDirectory, + resolvePath: function (path) { return _path.resolve(path); }, + fileExists: fileExists, + directoryExists: directoryExists, + createDirectory: function (directoryName) { + if (!nodeSystem.directoryExists(directoryName)) { + try { + _fs.mkdirSync(directoryName); + } + catch (e) { + if (e.code !== "EEXIST") { + throw e; + } + } + } + }, + getExecutingFilePath: function () { + return __filename; + }, + getCurrentDirectory: function () { + return process.cwd(); + }, + getDirectories: getDirectories, + getEnvironmentVariable: function (name) { + return process.env[name] || ""; + }, + readDirectory: readDirectory, + getModifiedTime: getModifiedTime, + setModifiedTime: setModifiedTime, + deleteFile: deleteFile, + createHash: _crypto ? createSHA256Hash : generateDjb2Hash, + createSHA256Hash: _crypto ? createSHA256Hash : undefined, + getMemoryUsage: function () { + if (global.gc) { + global.gc(); + } + return process.memoryUsage().heapUsed; + }, + getFileSize: function (path) { + try { + var stat = _fs.statSync(path); + if (stat.isFile()) { + return stat.size; + } + } + catch (_a) { } + return 0; + }, + exit: function (exitCode) { + disableCPUProfiler(function () { return process.exit(exitCode); }); + }, + enableCPUProfiler: enableCPUProfiler, + disableCPUProfiler: disableCPUProfiler, + realpath: realpath, + debugMode: ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }), + tryEnableSourceMapsForHost: function () { + try { + require("source-map-support").install(); + } + catch (_a) { + } + }, + setTimeout: setTimeout, + clearTimeout: clearTimeout, + clearScreen: function () { + process.stdout.write("\x1Bc"); + }, + setBlocking: function () { + if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) { + process.stdout._handle.setBlocking(true); + } + }, + bufferFrom: bufferFrom, + base64decode: function (input) { return bufferFrom(input, "base64").toString("utf8"); }, + base64encode: function (input) { return bufferFrom(input).toString("base64"); }, + require: function (baseDir, moduleName) { + try { + var modulePath = ts.resolveJSModule(moduleName, baseDir, nodeSystem); + return { module: require(modulePath), modulePath: modulePath, error: undefined }; + } + catch (error) { + return { module: undefined, modulePath: undefined, error: error }; + } + } + }; + return nodeSystem; + function enableCPUProfiler(path, cb) { + if (activeSession) { + cb(); + return false; + } + var inspector = require("inspector"); + if (!inspector || !inspector.Session) { + cb(); + return false; + } + var session = new inspector.Session(); + session.connect(); + session.post("Profiler.enable", function () { + session.post("Profiler.start", function () { + activeSession = session; + profilePath = path; + cb(); + }); + }); + return true; + } + function cleanupPaths(profile) { + var externalFileCounter = 0; + var remappedPaths = ts.createMap(); + var normalizedDir = ts.normalizeSlashes(__dirname); + var fileUrlRoot = "file://" + (ts.getRootLength(normalizedDir) === 1 ? "" : "/") + normalizedDir; + for (var _i = 0, _a = profile.nodes; _i < _a.length; _i++) { + var node = _a[_i]; + if (node.callFrame.url) { + var url = ts.normalizeSlashes(node.callFrame.url); + if (ts.containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) { + node.callFrame.url = ts.getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, ts.createGetCanonicalFileName(useCaseSensitiveFileNames), true); + } + else if (!nativePattern.test(url)) { + node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, "external" + externalFileCounter + ".js")).get(url); + externalFileCounter++; + } + } + } + return profile; + } + function disableCPUProfiler(cb) { + if (activeSession && activeSession !== "stopping") { + var s_1 = activeSession; + activeSession.post("Profiler.stop", function (err, _a) { + var profile = _a.profile; + if (!err) { + try { + if (_fs.statSync(profilePath).isDirectory()) { + profilePath = _path.join(profilePath, (new Date()).toISOString().replace(/:/g, "-") + "+P" + process.pid + ".cpuprofile"); + } + } + catch (_b) { + } + try { + _fs.mkdirSync(_path.dirname(profilePath), { recursive: true }); + } + catch (_c) { + } + _fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile))); + } + activeSession = undefined; + s_1.disconnect(); + cb(); + }); + activeSession = "stopping"; + return true; + } + else { + cb(); + return false; + } + } + function bufferFrom(input, encoding) { + return Buffer.from && Buffer.from !== Int8Array.from + ? Buffer.from(input, encoding) + : new Buffer(input, encoding); + } + function isFileSystemCaseSensitive() { + if (platform === "win32" || platform === "win64") { + return false; + } + return !fileExists(swapCase(__filename)); + } + function swapCase(s) { + return s.replace(/\w/g, function (ch) { + var up = ch.toUpperCase(); + return ch === up ? ch.toLowerCase() : up; + }); + } + function fsWatchFileWorker(fileName, callback, pollingInterval) { + _fs.watchFile(fileName, { persistent: true, interval: pollingInterval }, fileChanged); + var eventKind; + return { + close: function () { return _fs.unwatchFile(fileName, fileChanged); } + }; + function fileChanged(curr, prev) { + var isPreviouslyDeleted = +prev.mtime === 0 || eventKind === FileWatcherEventKind.Deleted; + if (+curr.mtime === 0) { + if (isPreviouslyDeleted) { + return; + } + eventKind = FileWatcherEventKind.Deleted; + } + else if (isPreviouslyDeleted) { + eventKind = FileWatcherEventKind.Created; + } + else if (+curr.mtime === +prev.mtime) { + return; + } + else { + eventKind = FileWatcherEventKind.Changed; + } + callback(fileName, eventKind); + } + } + function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) { + var options; + var lastDirectoryPartWithDirectorySeparator; + var lastDirectoryPart; + if (isLinuxOrMacOs) { + lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator)); + lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length); + } + var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ? + watchMissingFileSystemEntry() : + watchPresentFileSystemEntry(); + return { + close: function () { + watcher.close(); + watcher = undefined; + } + }; + function invokeCallbackAndUpdateWatcher(createWatcher) { + ts.sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher"); + callback("rename", ""); + if (watcher) { + watcher.close(); + watcher = createWatcher(); + } + } + function watchPresentFileSystemEntry() { + if (options === undefined) { + if (fsSupportsRecursiveFsWatch) { + options = { persistent: true, recursive: !!recursive }; + } + else { + options = { persistent: true }; + } + } + try { + var presentWatcher = _fs.watch(fileOrDirectory, options, isLinuxOrMacOs ? + callbackChangingToMissingFileSystemEntry : + callback); + presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); }); + return presentWatcher; + } + catch (e) { + return watchPresentFileSystemEntryWithFsWatchFile(); + } + } + function callbackChangingToMissingFileSystemEntry(event, relativeName) { + return event === "rename" && + (!relativeName || + relativeName === lastDirectoryPart || + relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length) && + !fileSystemEntryExists(fileOrDirectory, entryKind) ? + invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry) : + callback(event, relativeName); + } + function watchPresentFileSystemEntryWithFsWatchFile() { + ts.sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile"); + return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions); + } + function watchMissingFileSystemEntry() { + return watchFile(fileOrDirectory, function (_fileName, eventKind) { + if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) { + invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry); + } + }, fallbackPollingInterval, fallbackOptions); + } + } + function readFileWorker(fileName, _encoding) { + var buffer; + try { + buffer = _fs.readFileSync(fileName); + } + catch (e) { + return undefined; + } + var len = buffer.length; + if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { + len &= ~1; + for (var i = 0; i < len; i += 2) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + } + return buffer.toString("utf16le", 2); + } + if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { + return buffer.toString("utf16le", 2); + } + if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { + return buffer.toString("utf8", 3); + } + return buffer.toString("utf8"); + } + function readFile(fileName, _encoding) { + ts.perfLogger.logStartReadFile(fileName); + var file = readFileWorker(fileName, _encoding); + ts.perfLogger.logStopReadFile(); + return file; + } + function writeFile(fileName, data, writeByteOrderMark) { + ts.perfLogger.logEvent("WriteFile: " + fileName); + if (writeByteOrderMark) { + data = byteOrderMarkIndicator + data; + } + var fd; + try { + fd = _fs.openSync(fileName, "w"); + _fs.writeSync(fd, data, undefined, "utf8"); + } + finally { + if (fd !== undefined) { + _fs.closeSync(fd); + } + } + } + function getAccessibleFileSystemEntries(path) { + ts.perfLogger.logEvent("ReadDir: " + (path || ".")); + try { + var entries = _fs.readdirSync(path || ".", { withFileTypes: true }); + var files = []; + var directories = []; + for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) { + var dirent = entries_2[_i]; + var entry = typeof dirent === "string" ? dirent : dirent.name; + if (entry === "." || entry === "..") { + continue; + } + var stat = void 0; + if (typeof dirent === "string" || dirent.isSymbolicLink()) { + var name = ts.combinePaths(path, entry); + try { + stat = _fs.statSync(name); + } + catch (e) { + continue; + } + } + else { + stat = dirent; + } + if (stat.isFile()) { + files.push(entry); + } + else if (stat.isDirectory()) { + directories.push(entry); + } + } + files.sort(); + directories.sort(); + return { files: files, directories: directories }; + } + catch (e) { + return ts.emptyFileSystemEntries; + } + } + function readDirectory(path, extensions, excludes, includes, depth) { + return ts.matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath); + } + function fileSystemEntryExists(path, entryKind) { + try { + var stat = _fs.statSync(path); + switch (entryKind) { + case 0: return stat.isFile(); + case 1: return stat.isDirectory(); + default: return false; + } + } + catch (e) { + return false; + } + } + function fileExists(path) { + return fileSystemEntryExists(path, 0); + } + function directoryExists(path) { + return fileSystemEntryExists(path, 1); + } + function getDirectories(path) { + return getAccessibleFileSystemEntries(path).directories.slice(); + } + function realpath(path) { + try { + return _fs.realpathSync(path); + } + catch (_a) { + return path; + } + } + function getModifiedTime(path) { + try { + return _fs.statSync(path).mtime; + } + catch (e) { + return undefined; + } + } + function setModifiedTime(path, time) { + try { + _fs.utimesSync(path, time, time); + } + catch (e) { + return; + } + } + function deleteFile(path) { + try { + return _fs.unlinkSync(path); + } + catch (e) { + return; + } + } + function createSHA256Hash(data) { + var hash = _crypto.createHash("sha256"); + hash.update(data); + return hash.digest("hex"); + } + } + function getChakraSystem() { + var realpath = ChakraHost.realpath && (function (path) { return ChakraHost.realpath(path); }); + return { + newLine: ChakraHost.newLine || "\r\n", + args: ChakraHost.args, + useCaseSensitiveFileNames: !!ChakraHost.useCaseSensitiveFileNames, + write: ChakraHost.echo, + readFile: function (path, _encoding) { + return ChakraHost.readFile(path); + }, + writeFile: function (path, data, writeByteOrderMark) { + if (writeByteOrderMark) { + data = byteOrderMarkIndicator + data; + } + ChakraHost.writeFile(path, data); + }, + resolvePath: ChakraHost.resolvePath, + fileExists: ChakraHost.fileExists, + deleteFile: ChakraHost.deleteFile, + getModifiedTime: ChakraHost.getModifiedTime, + setModifiedTime: ChakraHost.setModifiedTime, + directoryExists: ChakraHost.directoryExists, + createDirectory: ChakraHost.createDirectory, + getExecutingFilePath: function () { return ChakraHost.executingFile; }, + getCurrentDirectory: function () { return ChakraHost.currentDirectory; }, + getDirectories: ChakraHost.getDirectories, + getEnvironmentVariable: ChakraHost.getEnvironmentVariable || (function () { return ""; }), + readDirectory: function (path, extensions, excludes, includes, _depth) { + var pattern = ts.getFileMatcherPatterns(path, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory); + return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern); + }, + exit: ChakraHost.quit, + realpath: realpath + }; + } + var sys; + if (typeof ChakraHost !== "undefined") { + sys = getChakraSystem(); + } + else if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof require !== "undefined") { + sys = getNodeSystem(); + } + if (sys) { + patchWriteFileEnsuringDirectory(sys); + } + return sys; + })(); + if (ts.sys && ts.sys.getEnvironmentVariable) { + setCustomPollingValues(ts.sys); + ts.Debug.currentAssertionLevel = /^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV")) + ? 1 + : 0; + } + if (ts.sys && ts.sys.debugMode) { + ts.Debug.isDebugging = true; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.directorySeparator = "/"; + var altDirectorySeparator = "\\"; + var urlSchemeSeparator = "://"; + var backslashRegExp = /\\/g; + function isAnyDirectorySeparator(charCode) { + return charCode === 47 || charCode === 92; + } + ts.isAnyDirectorySeparator = isAnyDirectorySeparator; + function isUrl(path) { + return getEncodedRootLength(path) < 0; + } + ts.isUrl = isUrl; + function isRootedDiskPath(path) { + return getEncodedRootLength(path) > 0; + } + ts.isRootedDiskPath = isRootedDiskPath; + function isDiskPathRoot(path) { + var rootLength = getEncodedRootLength(path); + return rootLength > 0 && rootLength === path.length; + } + ts.isDiskPathRoot = isDiskPathRoot; + function pathIsAbsolute(path) { + return getEncodedRootLength(path) !== 0; + } + ts.pathIsAbsolute = pathIsAbsolute; + function pathIsRelative(path) { + return /^\.\.?($|[\\/])/.test(path); + } + ts.pathIsRelative = pathIsRelative; + function hasExtension(fileName) { + return ts.stringContains(getBaseFileName(fileName), "."); + } + ts.hasExtension = hasExtension; + function fileExtensionIs(path, extension) { + return path.length > extension.length && ts.endsWith(path, extension); + } + ts.fileExtensionIs = fileExtensionIs; + function fileExtensionIsOneOf(path, extensions) { + for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) { + var extension = extensions_1[_i]; + if (fileExtensionIs(path, extension)) { + return true; + } + } + return false; + } + ts.fileExtensionIsOneOf = fileExtensionIsOneOf; + function hasTrailingDirectorySeparator(path) { + return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1)); + } + ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator; + function isVolumeCharacter(charCode) { + return (charCode >= 97 && charCode <= 122) || + (charCode >= 65 && charCode <= 90); + } + function getFileUrlVolumeSeparatorEnd(url, start) { + var ch0 = url.charCodeAt(start); + if (ch0 === 58) + return start + 1; + if (ch0 === 37 && url.charCodeAt(start + 1) === 51) { + var ch2 = url.charCodeAt(start + 2); + if (ch2 === 97 || ch2 === 65) + return start + 3; + } + return -1; + } + function getEncodedRootLength(path) { + if (!path) + return 0; + var ch0 = path.charCodeAt(0); + if (ch0 === 47 || ch0 === 92) { + if (path.charCodeAt(1) !== ch0) + return 1; + var p1 = path.indexOf(ch0 === 47 ? ts.directorySeparator : altDirectorySeparator, 2); + if (p1 < 0) + return path.length; + return p1 + 1; + } + if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) { + var ch2 = path.charCodeAt(2); + if (ch2 === 47 || ch2 === 92) + return 3; + if (path.length === 2) + return 2; + } + var schemeEnd = path.indexOf(urlSchemeSeparator); + if (schemeEnd !== -1) { + var authorityStart = schemeEnd + urlSchemeSeparator.length; + var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart); + if (authorityEnd !== -1) { + var scheme = path.slice(0, schemeEnd); + var authority = path.slice(authorityStart, authorityEnd); + if (scheme === "file" && (authority === "" || authority === "localhost") && + isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) { + var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2); + if (volumeSeparatorEnd !== -1) { + if (path.charCodeAt(volumeSeparatorEnd) === 47) { + return ~(volumeSeparatorEnd + 1); + } + if (volumeSeparatorEnd === path.length) { + return ~volumeSeparatorEnd; + } + } + } + return ~(authorityEnd + 1); + } + return ~path.length; + } + return 0; + } + function getRootLength(path) { + var rootLength = getEncodedRootLength(path); + return rootLength < 0 ? ~rootLength : rootLength; + } + ts.getRootLength = getRootLength; + function getDirectoryPath(path) { + path = normalizeSlashes(path); + var rootLength = getRootLength(path); + if (rootLength === path.length) + return path; + path = removeTrailingDirectorySeparator(path); + return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator))); + } + ts.getDirectoryPath = getDirectoryPath; + function getBaseFileName(path, extensions, ignoreCase) { + path = normalizeSlashes(path); + var rootLength = getRootLength(path); + if (rootLength === path.length) + return ""; + path = removeTrailingDirectorySeparator(path); + var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1)); + var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined; + return extension ? name.slice(0, name.length - extension.length) : name; + } + ts.getBaseFileName = getBaseFileName; + function tryGetExtensionFromPath(path, extension, stringEqualityComparer) { + if (!ts.startsWith(extension, ".")) + extension = "." + extension; + if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) { + var pathExtension = path.slice(path.length - extension.length); + if (stringEqualityComparer(pathExtension, extension)) { + return pathExtension; + } + } + } + function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) { + if (typeof extensions === "string") { + return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || ""; + } + for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) { + var extension = extensions_2[_i]; + var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer); + if (result) + return result; + } + return ""; + } + function getAnyExtensionFromPath(path, extensions, ignoreCase) { + if (extensions) { + return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive); + } + var baseFileName = getBaseFileName(path); + var extensionIndex = baseFileName.lastIndexOf("."); + if (extensionIndex >= 0) { + return baseFileName.substring(extensionIndex); + } + return ""; + } + ts.getAnyExtensionFromPath = getAnyExtensionFromPath; + function pathComponents(path, rootLength) { + var root = path.substring(0, rootLength); + var rest = path.substring(rootLength).split(ts.directorySeparator); + if (rest.length && !ts.lastOrUndefined(rest)) + rest.pop(); + return __spreadArrays([root], rest); + } + function getPathComponents(path, currentDirectory) { + if (currentDirectory === void 0) { currentDirectory = ""; } + path = combinePaths(currentDirectory, path); + return pathComponents(path, getRootLength(path)); + } + ts.getPathComponents = getPathComponents; + function getPathFromPathComponents(pathComponents) { + if (pathComponents.length === 0) + return ""; + var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]); + return root + pathComponents.slice(1).join(ts.directorySeparator); + } + ts.getPathFromPathComponents = getPathFromPathComponents; + function normalizeSlashes(path) { + return path.replace(backslashRegExp, ts.directorySeparator); + } + ts.normalizeSlashes = normalizeSlashes; + function reducePathComponents(components) { + if (!ts.some(components)) + return []; + var reduced = [components[0]]; + for (var i = 1; i < components.length; i++) { + var component = components[i]; + if (!component) + continue; + if (component === ".") + continue; + if (component === "..") { + if (reduced.length > 1) { + if (reduced[reduced.length - 1] !== "..") { + reduced.pop(); + continue; + } + } + else if (reduced[0]) + continue; + } + reduced.push(component); + } + return reduced; + } + ts.reducePathComponents = reducePathComponents; + function combinePaths(path) { + var paths = []; + for (var _i = 1; _i < arguments.length; _i++) { + paths[_i - 1] = arguments[_i]; + } + if (path) + path = normalizeSlashes(path); + for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) { + var relativePath = paths_1[_a]; + if (!relativePath) + continue; + relativePath = normalizeSlashes(relativePath); + if (!path || getRootLength(relativePath) !== 0) { + path = relativePath; + } + else { + path = ensureTrailingDirectorySeparator(path) + relativePath; + } + } + return path; + } + ts.combinePaths = combinePaths; + function resolvePath(path) { + var paths = []; + for (var _i = 1; _i < arguments.length; _i++) { + paths[_i - 1] = arguments[_i]; + } + return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArrays([path], paths)) : normalizeSlashes(path)); + } + ts.resolvePath = resolvePath; + function getNormalizedPathComponents(path, currentDirectory) { + return reducePathComponents(getPathComponents(path, currentDirectory)); + } + ts.getNormalizedPathComponents = getNormalizedPathComponents; + function getNormalizedAbsolutePath(fileName, currentDirectory) { + return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory)); + } + ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath; + function normalizePath(path) { + path = normalizeSlashes(path); + var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path))); + return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized; + } + ts.normalizePath = normalizePath; + function getPathWithoutRoot(pathComponents) { + if (pathComponents.length === 0) + return ""; + return pathComponents.slice(1).join(ts.directorySeparator); + } + function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) { + return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory)); + } + ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot; + function toPath(fileName, basePath, getCanonicalFileName) { + var nonCanonicalizedPath = isRootedDiskPath(fileName) + ? normalizePath(fileName) + : getNormalizedAbsolutePath(fileName, basePath); + return getCanonicalFileName(nonCanonicalizedPath); + } + ts.toPath = toPath; + function normalizePathAndParts(path) { + path = normalizeSlashes(path); + var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1); + if (parts.length) { + var joinedParts = root + parts.join(ts.directorySeparator); + return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts }; + } + else { + return { path: root, parts: parts }; + } + } + ts.normalizePathAndParts = normalizePathAndParts; + function removeTrailingDirectorySeparator(path) { + if (hasTrailingDirectorySeparator(path)) { + return path.substr(0, path.length - 1); + } + return path; + } + ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator; + function ensureTrailingDirectorySeparator(path) { + if (!hasTrailingDirectorySeparator(path)) { + return path + ts.directorySeparator; + } + return path; + } + ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator; + function ensurePathIsNonModuleName(path) { + return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path; + } + ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName; + function changeAnyExtension(path, ext, extensions, ignoreCase) { + var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path); + return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path; + } + ts.changeAnyExtension = changeAnyExtension; + var relativePathSegmentRegExp = /(^|\/)\.{0,2}($|\/)/; + function comparePathsWorker(a, b, componentComparer) { + if (a === b) + return 0; + if (a === undefined) + return -1; + if (b === undefined) + return 1; + var aRoot = a.substring(0, getRootLength(a)); + var bRoot = b.substring(0, getRootLength(b)); + var result = ts.compareStringsCaseInsensitive(aRoot, bRoot); + if (result !== 0) { + return result; + } + var aRest = a.substring(aRoot.length); + var bRest = b.substring(bRoot.length); + if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) { + return componentComparer(aRest, bRest); + } + var aComponents = reducePathComponents(getPathComponents(a)); + var bComponents = reducePathComponents(getPathComponents(b)); + var sharedLength = Math.min(aComponents.length, bComponents.length); + for (var i = 1; i < sharedLength; i++) { + var result_1 = componentComparer(aComponents[i], bComponents[i]); + if (result_1 !== 0) { + return result_1; + } + } + return ts.compareValues(aComponents.length, bComponents.length); + } + function comparePathsCaseSensitive(a, b) { + return comparePathsWorker(a, b, ts.compareStringsCaseSensitive); + } + ts.comparePathsCaseSensitive = comparePathsCaseSensitive; + function comparePathsCaseInsensitive(a, b) { + return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive); + } + ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive; + function comparePaths(a, b, currentDirectory, ignoreCase) { + if (typeof currentDirectory === "string") { + a = combinePaths(currentDirectory, a); + b = combinePaths(currentDirectory, b); + } + else if (typeof currentDirectory === "boolean") { + ignoreCase = currentDirectory; + } + return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase)); + } + ts.comparePaths = comparePaths; + function containsPath(parent, child, currentDirectory, ignoreCase) { + if (typeof currentDirectory === "string") { + parent = combinePaths(currentDirectory, parent); + child = combinePaths(currentDirectory, child); + } + else if (typeof currentDirectory === "boolean") { + ignoreCase = currentDirectory; + } + if (parent === undefined || child === undefined) + return false; + if (parent === child) + return true; + var parentComponents = reducePathComponents(getPathComponents(parent)); + var childComponents = reducePathComponents(getPathComponents(child)); + if (childComponents.length < parentComponents.length) { + return false; + } + var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive; + for (var i = 0; i < parentComponents.length; i++) { + var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer; + if (!equalityComparer(parentComponents[i], childComponents[i])) { + return false; + } + } + return true; + } + ts.containsPath = containsPath; + function startsWithDirectory(fileName, directoryName, getCanonicalFileName) { + var canonicalFileName = getCanonicalFileName(fileName); + var canonicalDirectoryName = getCanonicalFileName(directoryName); + return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\"); + } + ts.startsWithDirectory = startsWithDirectory; + function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) { + var fromComponents = reducePathComponents(getPathComponents(from)); + var toComponents = reducePathComponents(getPathComponents(to)); + var start; + for (start = 0; start < fromComponents.length && start < toComponents.length; start++) { + var fromComponent = getCanonicalFileName(fromComponents[start]); + var toComponent = getCanonicalFileName(toComponents[start]); + var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer; + if (!comparer(fromComponent, toComponent)) + break; + } + if (start === 0) { + return toComponents; + } + var components = toComponents.slice(start); + var relative = []; + for (; start < fromComponents.length; start++) { + relative.push(".."); + } + return __spreadArrays([""], relative, components); + } + ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo; + function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) { + ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative"); + var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity; + var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false; + var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName); + return getPathFromPathComponents(pathComponents); + } + ts.getRelativePathFromDirectory = getRelativePathFromDirectory; + function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) { + return !isRootedDiskPath(absoluteOrRelativePath) + ? absoluteOrRelativePath + : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false); + } + ts.convertToRelativePath = convertToRelativePath; + function getRelativePathFromFile(from, to, getCanonicalFileName) { + return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName)); + } + ts.getRelativePathFromFile = getRelativePathFromFile; + function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) { + var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName); + var firstComponent = pathComponents[0]; + if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) { + var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///"; + pathComponents[0] = prefix + firstComponent; + } + return getPathFromPathComponents(pathComponents); + } + ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl; + function forEachAncestorDirectory(directory, callback) { + while (true) { + var result = callback(directory); + if (result !== undefined) { + return result; + } + var parentPath = getDirectoryPath(directory); + if (parentPath === directory) { + return undefined; + } + directory = parentPath; + } + } + ts.forEachAncestorDirectory = forEachAncestorDirectory; +})(ts || (ts = {})); +var ts; +(function (ts) { + function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid) { + return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid }; + } + ts.Diagnostics = { + Unterminated_string_literal: diag(1002, ts.DiagnosticCategory.Error, "Unterminated_string_literal_1002", "Unterminated string literal."), + Identifier_expected: diag(1003, ts.DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."), + _0_expected: diag(1005, ts.DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."), + A_file_cannot_have_a_reference_to_itself: diag(1006, ts.DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."), + The_parser_expected_to_find_a_to_match_the_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_to_match_the_token_here_1007", "The parser expected to find a '}' to match the '{' token here."), + Trailing_comma_not_allowed: diag(1009, ts.DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."), + Asterisk_Slash_expected: diag(1010, ts.DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."), + An_element_access_expression_should_take_an_argument: diag(1011, ts.DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."), + Unexpected_token: diag(1012, ts.DiagnosticCategory.Error, "Unexpected_token_1012", "Unexpected token."), + A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, ts.DiagnosticCategory.Error, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."), + A_rest_parameter_must_be_last_in_a_parameter_list: diag(1014, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."), + Parameter_cannot_have_question_mark_and_initializer: diag(1015, ts.DiagnosticCategory.Error, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."), + A_required_parameter_cannot_follow_an_optional_parameter: diag(1016, ts.DiagnosticCategory.Error, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."), + An_index_signature_cannot_have_a_rest_parameter: diag(1017, ts.DiagnosticCategory.Error, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."), + An_index_signature_parameter_cannot_have_an_accessibility_modifier: diag(1018, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."), + An_index_signature_parameter_cannot_have_a_question_mark: diag(1019, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."), + An_index_signature_parameter_cannot_have_an_initializer: diag(1020, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."), + An_index_signature_must_have_a_type_annotation: diag(1021, ts.DiagnosticCategory.Error, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."), + An_index_signature_parameter_must_have_a_type_annotation: diag(1022, ts.DiagnosticCategory.Error, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."), + An_index_signature_parameter_type_must_be_either_string_or_number: diag(1023, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_either_string_or_number_1023", "An index signature parameter type must be either 'string' or 'number'."), + readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: diag(1024, ts.DiagnosticCategory.Error, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."), + Accessibility_modifier_already_seen: diag(1028, ts.DiagnosticCategory.Error, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."), + _0_modifier_must_precede_1_modifier: diag(1029, ts.DiagnosticCategory.Error, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."), + _0_modifier_already_seen: diag(1030, ts.DiagnosticCategory.Error, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."), + _0_modifier_cannot_appear_on_a_class_element: diag(1031, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_class_element_1031", "'{0}' modifier cannot appear on a class element."), + super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, ts.DiagnosticCategory.Error, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."), + Only_ambient_modules_can_use_quoted_names: diag(1035, ts.DiagnosticCategory.Error, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."), + Statements_are_not_allowed_in_ambient_contexts: diag(1036, ts.DiagnosticCategory.Error, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."), + A_declare_modifier_cannot_be_used_in_an_already_ambient_context: diag(1038, ts.DiagnosticCategory.Error, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."), + Initializers_are_not_allowed_in_ambient_contexts: diag(1039, ts.DiagnosticCategory.Error, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."), + _0_modifier_cannot_be_used_in_an_ambient_context: diag(1040, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."), + _0_modifier_cannot_be_used_with_a_class_declaration: diag(1041, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_class_declaration_1041", "'{0}' modifier cannot be used with a class declaration."), + _0_modifier_cannot_be_used_here: diag(1042, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."), + _0_modifier_cannot_appear_on_a_data_property: diag(1043, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_data_property_1043", "'{0}' modifier cannot appear on a data property."), + _0_modifier_cannot_appear_on_a_module_or_namespace_element: diag(1044, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."), + A_0_modifier_cannot_be_used_with_an_interface_declaration: diag(1045, ts.DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_interface_declaration_1045", "A '{0}' modifier cannot be used with an interface declaration."), + Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier: diag(1046, ts.DiagnosticCategory.Error, "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046", "Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier."), + A_rest_parameter_cannot_be_optional: diag(1047, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."), + A_rest_parameter_cannot_have_an_initializer: diag(1048, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."), + A_set_accessor_must_have_exactly_one_parameter: diag(1049, ts.DiagnosticCategory.Error, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."), + A_set_accessor_cannot_have_an_optional_parameter: diag(1051, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."), + A_set_accessor_parameter_cannot_have_an_initializer: diag(1052, ts.DiagnosticCategory.Error, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."), + A_set_accessor_cannot_have_rest_parameter: diag(1053, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."), + A_get_accessor_cannot_have_parameters: diag(1054, ts.DiagnosticCategory.Error, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."), + Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: diag(1055, ts.DiagnosticCategory.Error, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Prom_1055", "Type '{0}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value."), + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: diag(1056, ts.DiagnosticCategory.Error, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."), + An_async_function_or_method_must_have_a_valid_awaitable_return_type: diag(1057, ts.DiagnosticCategory.Error, "An_async_function_or_method_must_have_a_valid_awaitable_return_type_1057", "An async function or method must have a valid awaitable return type."), + The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1058, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."), + A_promise_must_have_a_then_method: diag(1059, ts.DiagnosticCategory.Error, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."), + The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: diag(1060, ts.DiagnosticCategory.Error, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."), + Enum_member_must_have_initializer: diag(1061, ts.DiagnosticCategory.Error, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."), + Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, ts.DiagnosticCategory.Error, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."), + An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."), + The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1064, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1064", "The return type of an async function or method must be the global Promise type."), + In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, ts.DiagnosticCategory.Error, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."), + Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, ts.DiagnosticCategory.Error, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."), + Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, ts.DiagnosticCategory.Error, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."), + _0_modifier_cannot_appear_on_a_type_member: diag(1070, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."), + _0_modifier_cannot_appear_on_an_index_signature: diag(1071, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."), + A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, ts.DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."), + Invalid_reference_directive_syntax: diag(1084, ts.DiagnosticCategory.Error, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."), + Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, ts.DiagnosticCategory.Error, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."), + _0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."), + _0_modifier_cannot_appear_on_a_parameter: diag(1090, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."), + Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."), + Type_parameters_cannot_appear_on_a_constructor_declaration: diag(1092, ts.DiagnosticCategory.Error, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."), + Type_annotation_cannot_appear_on_a_constructor_declaration: diag(1093, ts.DiagnosticCategory.Error, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."), + An_accessor_cannot_have_type_parameters: diag(1094, ts.DiagnosticCategory.Error, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."), + A_set_accessor_cannot_have_a_return_type_annotation: diag(1095, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."), + An_index_signature_must_have_exactly_one_parameter: diag(1096, ts.DiagnosticCategory.Error, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."), + _0_list_cannot_be_empty: diag(1097, ts.DiagnosticCategory.Error, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."), + Type_parameter_list_cannot_be_empty: diag(1098, ts.DiagnosticCategory.Error, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."), + Type_argument_list_cannot_be_empty: diag(1099, ts.DiagnosticCategory.Error, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."), + Invalid_use_of_0_in_strict_mode: diag(1100, ts.DiagnosticCategory.Error, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."), + with_statements_are_not_allowed_in_strict_mode: diag(1101, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."), + delete_cannot_be_called_on_an_identifier_in_strict_mode: diag(1102, ts.DiagnosticCategory.Error, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."), + A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator: diag(1103, ts.DiagnosticCategory.Error, "A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator_1103", "A 'for-await-of' statement is only allowed within an async function or async generator."), + A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: diag(1104, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."), + A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: diag(1105, ts.DiagnosticCategory.Error, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."), + Jump_target_cannot_cross_function_boundary: diag(1107, ts.DiagnosticCategory.Error, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."), + A_return_statement_can_only_be_used_within_a_function_body: diag(1108, ts.DiagnosticCategory.Error, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."), + Expression_expected: diag(1109, ts.DiagnosticCategory.Error, "Expression_expected_1109", "Expression expected."), + Type_expected: diag(1110, ts.DiagnosticCategory.Error, "Type_expected_1110", "Type expected."), + A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, ts.DiagnosticCategory.Error, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."), + Duplicate_label_0: diag(1114, ts.DiagnosticCategory.Error, "Duplicate_label_0_1114", "Duplicate label '{0}'."), + A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."), + A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, ts.DiagnosticCategory.Error, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."), + An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: diag(1117, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode_1117", "An object literal cannot have multiple properties with the same name in strict mode."), + An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."), + An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."), + An_export_assignment_cannot_have_modifiers: diag(1120, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."), + Octal_literals_are_not_allowed_in_strict_mode: diag(1121, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."), + Variable_declaration_list_cannot_be_empty: diag(1123, ts.DiagnosticCategory.Error, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."), + Digit_expected: diag(1124, ts.DiagnosticCategory.Error, "Digit_expected_1124", "Digit expected."), + Hexadecimal_digit_expected: diag(1125, ts.DiagnosticCategory.Error, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."), + Unexpected_end_of_text: diag(1126, ts.DiagnosticCategory.Error, "Unexpected_end_of_text_1126", "Unexpected end of text."), + Invalid_character: diag(1127, ts.DiagnosticCategory.Error, "Invalid_character_1127", "Invalid character."), + Declaration_or_statement_expected: diag(1128, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_1128", "Declaration or statement expected."), + Statement_expected: diag(1129, ts.DiagnosticCategory.Error, "Statement_expected_1129", "Statement expected."), + case_or_default_expected: diag(1130, ts.DiagnosticCategory.Error, "case_or_default_expected_1130", "'case' or 'default' expected."), + Property_or_signature_expected: diag(1131, ts.DiagnosticCategory.Error, "Property_or_signature_expected_1131", "Property or signature expected."), + Enum_member_expected: diag(1132, ts.DiagnosticCategory.Error, "Enum_member_expected_1132", "Enum member expected."), + Variable_declaration_expected: diag(1134, ts.DiagnosticCategory.Error, "Variable_declaration_expected_1134", "Variable declaration expected."), + Argument_expression_expected: diag(1135, ts.DiagnosticCategory.Error, "Argument_expression_expected_1135", "Argument expression expected."), + Property_assignment_expected: diag(1136, ts.DiagnosticCategory.Error, "Property_assignment_expected_1136", "Property assignment expected."), + Expression_or_comma_expected: diag(1137, ts.DiagnosticCategory.Error, "Expression_or_comma_expected_1137", "Expression or comma expected."), + Parameter_declaration_expected: diag(1138, ts.DiagnosticCategory.Error, "Parameter_declaration_expected_1138", "Parameter declaration expected."), + Type_parameter_declaration_expected: diag(1139, ts.DiagnosticCategory.Error, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."), + Type_argument_expected: diag(1140, ts.DiagnosticCategory.Error, "Type_argument_expected_1140", "Type argument expected."), + String_literal_expected: diag(1141, ts.DiagnosticCategory.Error, "String_literal_expected_1141", "String literal expected."), + Line_break_not_permitted_here: diag(1142, ts.DiagnosticCategory.Error, "Line_break_not_permitted_here_1142", "Line break not permitted here."), + or_expected: diag(1144, ts.DiagnosticCategory.Error, "or_expected_1144", "'{' or ';' expected."), + Declaration_expected: diag(1146, ts.DiagnosticCategory.Error, "Declaration_expected_1146", "Declaration expected."), + Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, ts.DiagnosticCategory.Error, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."), + Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, ts.DiagnosticCategory.Error, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."), + File_name_0_differs_from_already_included_file_name_1_only_in_casing: diag(1149, ts.DiagnosticCategory.Error, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."), + const_declarations_must_be_initialized: diag(1155, ts.DiagnosticCategory.Error, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."), + const_declarations_can_only_be_declared_inside_a_block: diag(1156, ts.DiagnosticCategory.Error, "const_declarations_can_only_be_declared_inside_a_block_1156", "'const' declarations can only be declared inside a block."), + let_declarations_can_only_be_declared_inside_a_block: diag(1157, ts.DiagnosticCategory.Error, "let_declarations_can_only_be_declared_inside_a_block_1157", "'let' declarations can only be declared inside a block."), + Unterminated_template_literal: diag(1160, ts.DiagnosticCategory.Error, "Unterminated_template_literal_1160", "Unterminated template literal."), + Unterminated_regular_expression_literal: diag(1161, ts.DiagnosticCategory.Error, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."), + An_object_member_cannot_be_declared_optional: diag(1162, ts.DiagnosticCategory.Error, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."), + A_yield_expression_is_only_allowed_in_a_generator_body: diag(1163, ts.DiagnosticCategory.Error, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."), + Computed_property_names_are_not_allowed_in_enums: diag(1164, ts.DiagnosticCategory.Error, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."), + A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1165, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1166, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_1166", "A computed property name in a class property declaration must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1168, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1169, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1170, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_comma_expression_is_not_allowed_in_a_computed_property_name: diag(1171, ts.DiagnosticCategory.Error, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."), + extends_clause_already_seen: diag(1172, ts.DiagnosticCategory.Error, "extends_clause_already_seen_1172", "'extends' clause already seen."), + extends_clause_must_precede_implements_clause: diag(1173, ts.DiagnosticCategory.Error, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."), + Classes_can_only_extend_a_single_class: diag(1174, ts.DiagnosticCategory.Error, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."), + implements_clause_already_seen: diag(1175, ts.DiagnosticCategory.Error, "implements_clause_already_seen_1175", "'implements' clause already seen."), + Interface_declaration_cannot_have_implements_clause: diag(1176, ts.DiagnosticCategory.Error, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."), + Binary_digit_expected: diag(1177, ts.DiagnosticCategory.Error, "Binary_digit_expected_1177", "Binary digit expected."), + Octal_digit_expected: diag(1178, ts.DiagnosticCategory.Error, "Octal_digit_expected_1178", "Octal digit expected."), + Unexpected_token_expected: diag(1179, ts.DiagnosticCategory.Error, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."), + Property_destructuring_pattern_expected: diag(1180, ts.DiagnosticCategory.Error, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."), + Array_element_destructuring_pattern_expected: diag(1181, ts.DiagnosticCategory.Error, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."), + A_destructuring_declaration_must_have_an_initializer: diag(1182, ts.DiagnosticCategory.Error, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."), + An_implementation_cannot_be_declared_in_ambient_contexts: diag(1183, ts.DiagnosticCategory.Error, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."), + Modifiers_cannot_appear_here: diag(1184, ts.DiagnosticCategory.Error, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."), + Merge_conflict_marker_encountered: diag(1185, ts.DiagnosticCategory.Error, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."), + A_rest_element_cannot_have_an_initializer: diag(1186, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."), + A_parameter_property_may_not_be_declared_using_a_binding_pattern: diag(1187, ts.DiagnosticCategory.Error, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."), + Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: diag(1188, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."), + The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: diag(1189, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."), + The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: diag(1190, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."), + An_import_declaration_cannot_have_modifiers: diag(1191, ts.DiagnosticCategory.Error, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."), + Module_0_has_no_default_export: diag(1192, ts.DiagnosticCategory.Error, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."), + An_export_declaration_cannot_have_modifiers: diag(1193, ts.DiagnosticCategory.Error, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."), + Export_declarations_are_not_permitted_in_a_namespace: diag(1194, ts.DiagnosticCategory.Error, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."), + Catch_clause_variable_cannot_have_a_type_annotation: diag(1196, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_a_type_annotation_1196", "Catch clause variable cannot have a type annotation."), + Catch_clause_variable_cannot_have_an_initializer: diag(1197, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."), + An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, ts.DiagnosticCategory.Error, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."), + Unterminated_Unicode_escape_sequence: diag(1199, ts.DiagnosticCategory.Error, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."), + Line_terminator_not_permitted_before_arrow: diag(1200, ts.DiagnosticCategory.Error, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."), + Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(1202, ts.DiagnosticCategory.Error, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead."), + Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: diag(1203, ts.DiagnosticCategory.Error, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."), + Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type: diag(1205, ts.DiagnosticCategory.Error, "Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type_1205", "Re-exporting a type when the '--isolatedModules' flag is provided requires using 'export type'."), + Decorators_are_not_valid_here: diag(1206, ts.DiagnosticCategory.Error, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."), + Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, ts.DiagnosticCategory.Error, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."), + All_files_must_be_modules_when_the_isolatedModules_flag_is_provided: diag(1208, ts.DiagnosticCategory.Error, "All_files_must_be_modules_when_the_isolatedModules_flag_is_provided_1208", "All files must be modules when the '--isolatedModules' flag is provided."), + Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: diag(1210, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode_1210", "Invalid use of '{0}'. Class definitions are automatically in strict mode."), + A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, ts.DiagnosticCategory.Error, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: diag(1213, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: diag(1214, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."), + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: diag(1215, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."), + Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: diag(1216, ts.DiagnosticCategory.Error, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."), + Export_assignment_is_not_supported_when_module_flag_is_system: diag(1218, ts.DiagnosticCategory.Error, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."), + Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning: diag(1219, ts.DiagnosticCategory.Error, "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option in your 'tsconfig' or 'jsconfig' to remove this warning."), + Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher: diag(1220, ts.DiagnosticCategory.Error, "Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher_1220", "Generators are only available when targeting ECMAScript 2015 or higher."), + Generators_are_not_allowed_in_an_ambient_context: diag(1221, ts.DiagnosticCategory.Error, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."), + An_overload_signature_cannot_be_declared_as_a_generator: diag(1222, ts.DiagnosticCategory.Error, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."), + _0_tag_already_specified: diag(1223, ts.DiagnosticCategory.Error, "_0_tag_already_specified_1223", "'{0}' tag already specified."), + Signature_0_must_be_a_type_predicate: diag(1224, ts.DiagnosticCategory.Error, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."), + Cannot_find_parameter_0: diag(1225, ts.DiagnosticCategory.Error, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."), + Type_predicate_0_is_not_assignable_to_1: diag(1226, ts.DiagnosticCategory.Error, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."), + Parameter_0_is_not_in_the_same_position_as_parameter_1: diag(1227, ts.DiagnosticCategory.Error, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."), + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: diag(1228, ts.DiagnosticCategory.Error, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."), + A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."), + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."), + An_export_assignment_can_only_be_used_in_a_module: diag(1231, ts.DiagnosticCategory.Error, "An_export_assignment_can_only_be_used_in_a_module_1231", "An export assignment can only be used in a module."), + An_import_declaration_can_only_be_used_in_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", "An import declaration can only be used in a namespace or module."), + An_export_declaration_can_only_be_used_in_a_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_in_a_module_1233", "An export declaration can only be used in a module."), + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts.DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."), + A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", "A namespace declaration is only allowed in a namespace or module."), + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts.DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."), + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts.DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."), + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."), + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: diag(1239, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."), + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: diag(1240, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."), + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: diag(1241, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."), + abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: diag(1242, ts.DiagnosticCategory.Error, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."), + _0_modifier_cannot_be_used_with_1_modifier: diag(1243, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."), + Abstract_methods_can_only_appear_within_an_abstract_class: diag(1244, ts.DiagnosticCategory.Error, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."), + Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: diag(1245, ts.DiagnosticCategory.Error, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."), + An_interface_property_cannot_have_an_initializer: diag(1246, ts.DiagnosticCategory.Error, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."), + A_type_literal_property_cannot_have_an_initializer: diag(1247, ts.DiagnosticCategory.Error, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."), + A_class_member_cannot_have_the_0_keyword: diag(1248, ts.DiagnosticCategory.Error, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."), + A_decorator_can_only_decorate_a_method_implementation_not_an_overload: diag(1249, ts.DiagnosticCategory.Error, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."), + _0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag: diag(1253, ts.DiagnosticCategory.Error, "_0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag_1253", "'{0}' tag cannot be used independently as a top level JSDoc tag."), + A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, ts.DiagnosticCategory.Error, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."), + A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts.DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."), + A_rest_element_must_be_last_in_a_tuple_type: diag(1256, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_tuple_type_1256", "A rest element must be last in a tuple type."), + A_required_element_cannot_follow_an_optional_element: diag(1257, ts.DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."), + Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation: diag(1258, ts.DiagnosticCategory.Error, "Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation_1258", "Definite assignment assertions can only be used along with a type annotation."), + Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, ts.DiagnosticCategory.Error, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"), + Keywords_cannot_contain_escape_characters: diag(1260, ts.DiagnosticCategory.Error, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."), + Already_included_file_name_0_differs_from_file_name_1_only_in_casing: diag(1261, ts.DiagnosticCategory.Error, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."), + with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."), + await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."), + can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: diag(1312, ts.DiagnosticCategory.Error, "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", "'=' can only be used in an object literal property inside a destructuring assignment."), + The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts.DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."), + Global_module_exports_may_only_appear_in_module_files: diag(1314, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."), + Global_module_exports_may_only_appear_in_declaration_files: diag(1315, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."), + Global_module_exports_may_only_appear_at_top_level: diag(1316, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."), + A_parameter_property_cannot_be_declared_using_a_rest_parameter: diag(1317, ts.DiagnosticCategory.Error, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."), + An_abstract_accessor_cannot_have_an_implementation: diag(1318, ts.DiagnosticCategory.Error, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."), + A_default_export_can_only_be_used_in_an_ECMAScript_style_module: diag(1319, ts.DiagnosticCategory.Error, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."), + Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts.DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."), + Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."), + Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."), + Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'esnext', 'commonjs', 'amd', 'system', or 'umd'."), + Dynamic_import_must_have_one_specifier_as_an_argument: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_import_must_have_one_specifier_as_an_argument_1324", "Dynamic import must have one specifier as an argument."), + Specifier_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Specifier_of_dynamic_import_cannot_be_spread_element_1325", "Specifier of dynamic import cannot be spread element."), + Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments"), + String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."), + Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."), + _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"), + A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: diag(1330, ts.DiagnosticCategory.Error, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."), + A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: diag(1331, ts.DiagnosticCategory.Error, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."), + A_variable_whose_type_is_a_unique_symbol_type_must_be_const: diag(1332, ts.DiagnosticCategory.Error, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."), + unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: diag(1333, ts.DiagnosticCategory.Error, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."), + unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: diag(1334, ts.DiagnosticCategory.Error, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."), + unique_symbol_types_are_not_allowed_here: diag(1335, ts.DiagnosticCategory.Error, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."), + An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead: diag(1336, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead_1336", "An index signature parameter type cannot be a type alias. Consider writing '[{0}: {1}]: {2}' instead."), + An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead: diag(1337, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead_1337", "An index signature parameter type cannot be a union type. Consider using a mapped object type instead."), + infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: diag(1338, ts.DiagnosticCategory.Error, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."), + Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."), + Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"), + Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."), + The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system_1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'esnext' or 'system'."), + A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."), + An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness"), + This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."), + use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, ts.DiagnosticCategory.Error, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."), + Non_simple_parameter_declared_here: diag(1348, ts.DiagnosticCategory.Error, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."), + use_strict_directive_used_here: diag(1349, ts.DiagnosticCategory.Error, "use_strict_directive_used_here_1349", "'use strict' directive used here."), + Print_the_final_configuration_instead_of_building: diag(1350, ts.DiagnosticCategory.Message, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."), + An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: diag(1351, ts.DiagnosticCategory.Error, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."), + A_bigint_literal_cannot_use_exponential_notation: diag(1352, ts.DiagnosticCategory.Error, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."), + A_bigint_literal_must_be_an_integer: diag(1353, ts.DiagnosticCategory.Error, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."), + readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: diag(1354, ts.DiagnosticCategory.Error, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."), + A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals: diag(1355, ts.DiagnosticCategory.Error, "A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array__1355", "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals."), + Did_you_mean_to_mark_this_function_as_async: diag(1356, ts.DiagnosticCategory.Error, "Did_you_mean_to_mark_this_function_as_async_1356", "Did you mean to mark this function as 'async'?"), + An_enum_member_name_must_be_followed_by_a_or: diag(1357, ts.DiagnosticCategory.Error, "An_enum_member_name_must_be_followed_by_a_or_1357", "An enum member name must be followed by a ',', '=', or '}'."), + Tagged_template_expressions_are_not_permitted_in_an_optional_chain: diag(1358, ts.DiagnosticCategory.Error, "Tagged_template_expressions_are_not_permitted_in_an_optional_chain_1358", "Tagged template expressions are not permitted in an optional chain."), + Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here: diag(1359, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here_1359", "Identifier expected. '{0}' is a reserved word that cannot be used here."), + Did_you_mean_to_parenthesize_this_function_type: diag(1360, ts.DiagnosticCategory.Error, "Did_you_mean_to_parenthesize_this_function_type_1360", "Did you mean to parenthesize this function type?"), + _0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type: diag(1361, ts.DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type_1361", "'{0}' cannot be used as a value because it was imported using 'import type'."), + _0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type: diag(1362, ts.DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type_1362", "'{0}' cannot be used as a value because it was exported using 'export type'."), + A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both: diag(1363, ts.DiagnosticCategory.Error, "A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both_1363", "A type-only import can specify a default import or named bindings, but not both."), + Convert_to_type_only_export: diag(1364, ts.DiagnosticCategory.Message, "Convert_to_type_only_export_1364", "Convert to type-only export"), + Convert_all_re_exported_types_to_type_only_exports: diag(1365, ts.DiagnosticCategory.Message, "Convert_all_re_exported_types_to_type_only_exports_1365", "Convert all re-exported types to type-only exports"), + Split_into_two_separate_import_declarations: diag(1366, ts.DiagnosticCategory.Message, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"), + Split_all_invalid_type_only_imports: diag(1367, ts.DiagnosticCategory.Message, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"), + Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(1368, ts.DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_1368", "Specify emit/checking behavior for imports that are only used for types"), + Did_you_mean_0: diag(1369, ts.DiagnosticCategory.Message, "Did_you_mean_0_1369", "Did you mean '{0}'?"), + Only_ECMAScript_imports_may_use_import_type: diag(1370, ts.DiagnosticCategory.Error, "Only_ECMAScript_imports_may_use_import_type_1370", "Only ECMAScript imports may use 'import type'."), + This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is__1371", "This import is never used as a value and must use 'import type' because the 'importsNotUsedAsValues' is set to 'error'."), + Convert_to_type_only_import: diag(1373, ts.DiagnosticCategory.Message, "Convert_to_type_only_import_1373", "Convert to type-only import"), + Convert_all_imports_not_used_as_a_value_to_type_only_imports: diag(1374, ts.DiagnosticCategory.Message, "Convert_all_imports_not_used_as_a_value_to_type_only_imports_1374", "Convert all imports not used as a value to type-only imports"), + await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + _0_was_imported_here: diag(1376, ts.DiagnosticCategory.Message, "_0_was_imported_here_1376", "'{0}' was imported here."), + _0_was_exported_here: diag(1377, ts.DiagnosticCategory.Message, "_0_was_exported_here_1377", "'{0}' was exported here."), + Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_t_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher."), + An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."), + An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."), + Only_named_exports_may_use_export_type: diag(1383, ts.DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."), + The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), + The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), + Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", undefined, true), + Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, ts.DiagnosticCategory.Error, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", undefined, true), + Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, ts.DiagnosticCategory.Error, "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true), + Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true), + Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."), + Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), + Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."), + Circular_definition_of_import_alias_0: diag(2303, ts.DiagnosticCategory.Error, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."), + Cannot_find_name_0: diag(2304, ts.DiagnosticCategory.Error, "Cannot_find_name_0_2304", "Cannot find name '{0}'."), + Module_0_has_no_exported_member_1: diag(2305, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."), + File_0_is_not_a_module: diag(2306, ts.DiagnosticCategory.Error, "File_0_is_not_a_module_2306", "File '{0}' is not a module."), + Cannot_find_module_0: diag(2307, ts.DiagnosticCategory.Error, "Cannot_find_module_0_2307", "Cannot find module '{0}'."), + Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, ts.DiagnosticCategory.Error, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."), + An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."), + Type_0_recursively_references_itself_as_a_base_type: diag(2310, ts.DiagnosticCategory.Error, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."), + A_class_may_only_extend_another_class: diag(2311, ts.DiagnosticCategory.Error, "A_class_may_only_extend_another_class_2311", "A class may only extend another class."), + An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."), + Type_parameter_0_has_a_circular_constraint: diag(2313, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."), + Generic_type_0_requires_1_type_argument_s: diag(2314, ts.DiagnosticCategory.Error, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."), + Type_0_is_not_generic: diag(2315, ts.DiagnosticCategory.Error, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."), + Global_type_0_must_be_a_class_or_interface_type: diag(2316, ts.DiagnosticCategory.Error, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."), + Global_type_0_must_have_1_type_parameter_s: diag(2317, ts.DiagnosticCategory.Error, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."), + Cannot_find_global_type_0: diag(2318, ts.DiagnosticCategory.Error, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."), + Named_property_0_of_types_1_and_2_are_not_identical: diag(2319, ts.DiagnosticCategory.Error, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."), + Interface_0_cannot_simultaneously_extend_types_1_and_2: diag(2320, ts.DiagnosticCategory.Error, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."), + Excessive_stack_depth_comparing_types_0_and_1: diag(2321, ts.DiagnosticCategory.Error, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."), + Type_0_is_not_assignable_to_type_1: diag(2322, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."), + Cannot_redeclare_exported_variable_0: diag(2323, ts.DiagnosticCategory.Error, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."), + Property_0_is_missing_in_type_1: diag(2324, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."), + Property_0_is_private_in_type_1_but_not_in_type_2: diag(2325, ts.DiagnosticCategory.Error, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."), + Types_of_property_0_are_incompatible: diag(2326, ts.DiagnosticCategory.Error, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."), + Property_0_is_optional_in_type_1_but_required_in_type_2: diag(2327, ts.DiagnosticCategory.Error, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."), + Types_of_parameters_0_and_1_are_incompatible: diag(2328, ts.DiagnosticCategory.Error, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."), + Index_signature_is_missing_in_type_0: diag(2329, ts.DiagnosticCategory.Error, "Index_signature_is_missing_in_type_0_2329", "Index signature is missing in type '{0}'."), + Index_signatures_are_incompatible: diag(2330, ts.DiagnosticCategory.Error, "Index_signatures_are_incompatible_2330", "Index signatures are incompatible."), + this_cannot_be_referenced_in_a_module_or_namespace_body: diag(2331, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."), + this_cannot_be_referenced_in_current_location: diag(2332, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."), + this_cannot_be_referenced_in_constructor_arguments: diag(2333, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_constructor_arguments_2333", "'this' cannot be referenced in constructor arguments."), + this_cannot_be_referenced_in_a_static_property_initializer: diag(2334, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."), + super_can_only_be_referenced_in_a_derived_class: diag(2335, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."), + super_cannot_be_referenced_in_constructor_arguments: diag(2336, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."), + Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: diag(2337, ts.DiagnosticCategory.Error, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."), + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: diag(2338, ts.DiagnosticCategory.Error, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."), + Property_0_does_not_exist_on_type_1: diag(2339, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."), + Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: diag(2340, ts.DiagnosticCategory.Error, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."), + Property_0_is_private_and_only_accessible_within_class_1: diag(2341, ts.DiagnosticCategory.Error, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."), + An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: diag(2342, ts.DiagnosticCategory.Error, "An_index_expression_argument_must_be_of_type_string_number_symbol_or_any_2342", "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'."), + This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: diag(2343, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."), + Type_0_does_not_satisfy_the_constraint_1: diag(2344, ts.DiagnosticCategory.Error, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."), + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."), + Call_target_does_not_contain_any_signatures: diag(2346, ts.DiagnosticCategory.Error, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."), + Untyped_function_calls_may_not_accept_type_arguments: diag(2347, ts.DiagnosticCategory.Error, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."), + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, ts.DiagnosticCategory.Error, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"), + This_expression_is_not_callable: diag(2349, ts.DiagnosticCategory.Error, "This_expression_is_not_callable_2349", "This expression is not callable."), + Only_a_void_function_can_be_called_with_the_new_keyword: diag(2350, ts.DiagnosticCategory.Error, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."), + This_expression_is_not_constructable: diag(2351, ts.DiagnosticCategory.Error, "This_expression_is_not_constructable_2351", "This expression is not constructable."), + Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: diag(2352, ts.DiagnosticCategory.Error, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."), + Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: diag(2353, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."), + This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: diag(2354, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."), + A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: diag(2355, ts.DiagnosticCategory.Error, "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'void' nor 'any' must return a value."), + An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2356, ts.DiagnosticCategory.Error, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."), + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."), + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."), + The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."), + The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'."), + The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter_2361", "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter."), + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."), + Operator_0_cannot_be_applied_to_types_1_and_2: diag(2365, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."), + Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: diag(2366, ts.DiagnosticCategory.Error, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."), + This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap: diag(2367, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap_2367", "This condition will always return '{0}' since the types '{1}' and '{2}' have no overlap."), + Type_parameter_name_cannot_be_0: diag(2368, ts.DiagnosticCategory.Error, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."), + A_parameter_property_is_only_allowed_in_a_constructor_implementation: diag(2369, ts.DiagnosticCategory.Error, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."), + A_rest_parameter_must_be_of_an_array_type: diag(2370, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."), + A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: diag(2371, ts.DiagnosticCategory.Error, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."), + Parameter_0_cannot_be_referenced_in_its_initializer: diag(2372, ts.DiagnosticCategory.Error, "Parameter_0_cannot_be_referenced_in_its_initializer_2372", "Parameter '{0}' cannot be referenced in its initializer."), + Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts.DiagnosticCategory.Error, "Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it."), + Duplicate_string_index_signature: diag(2374, ts.DiagnosticCategory.Error, "Duplicate_string_index_signature_2374", "Duplicate string index signature."), + Duplicate_number_index_signature: diag(2375, ts.DiagnosticCategory.Error, "Duplicate_number_index_signature_2375", "Duplicate number index signature."), + A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", "A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers."), + Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts.DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."), + A_get_accessor_must_return_a_value: diag(2378, ts.DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."), + Getter_and_setter_accessors_do_not_agree_in_visibility: diag(2379, ts.DiagnosticCategory.Error, "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", "Getter and setter accessors do not agree in visibility."), + get_and_set_accessor_must_have_the_same_type: diag(2380, ts.DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_type_2380", "'get' and 'set' accessor must have the same type."), + A_signature_with_an_implementation_cannot_use_a_string_literal_type: diag(2381, ts.DiagnosticCategory.Error, "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", "A signature with an implementation cannot use a string literal type."), + Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: diag(2382, ts.DiagnosticCategory.Error, "Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature_2382", "Specialized overload signature is not assignable to any non-specialized signature."), + Overload_signatures_must_all_be_exported_or_non_exported: diag(2383, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."), + Overload_signatures_must_all_be_ambient_or_non_ambient: diag(2384, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."), + Overload_signatures_must_all_be_public_private_or_protected: diag(2385, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."), + Overload_signatures_must_all_be_optional_or_required: diag(2386, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."), + Function_overload_must_be_static: diag(2387, ts.DiagnosticCategory.Error, "Function_overload_must_be_static_2387", "Function overload must be static."), + Function_overload_must_not_be_static: diag(2388, ts.DiagnosticCategory.Error, "Function_overload_must_not_be_static_2388", "Function overload must not be static."), + Function_implementation_name_must_be_0: diag(2389, ts.DiagnosticCategory.Error, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."), + Constructor_implementation_is_missing: diag(2390, ts.DiagnosticCategory.Error, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."), + Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, ts.DiagnosticCategory.Error, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."), + Multiple_constructor_implementations_are_not_allowed: diag(2392, ts.DiagnosticCategory.Error, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."), + Duplicate_function_implementation: diag(2393, ts.DiagnosticCategory.Error, "Duplicate_function_implementation_2393", "Duplicate function implementation."), + This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, ts.DiagnosticCategory.Error, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."), + Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: diag(2395, ts.DiagnosticCategory.Error, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."), + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: diag(2396, ts.DiagnosticCategory.Error, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."), + Declaration_name_conflicts_with_built_in_global_identifier_0: diag(2397, ts.DiagnosticCategory.Error, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."), + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts.DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."), + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."), + Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: diag(2401, ts.DiagnosticCategory.Error, "Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference_2401", "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference."), + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts.DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."), + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts.DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'."), + The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."), + The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: diag(2405, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."), + The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: diag(2406, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."), + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: diag(2407, ts.DiagnosticCategory.Error, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."), + Setters_cannot_return_a_value: diag(2408, ts.DiagnosticCategory.Error, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."), + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: diag(2409, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."), + The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: diag(2410, ts.DiagnosticCategory.Error, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."), + Property_0_of_type_1_is_not_assignable_to_string_index_type_2: diag(2411, ts.DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_string_index_type_2_2411", "Property '{0}' of type '{1}' is not assignable to string index type '{2}'."), + Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: diag(2412, ts.DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2_2412", "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'."), + Numeric_index_type_0_is_not_assignable_to_string_index_type_1: diag(2413, ts.DiagnosticCategory.Error, "Numeric_index_type_0_is_not_assignable_to_string_index_type_1_2413", "Numeric index type '{0}' is not assignable to string index type '{1}'."), + Class_name_cannot_be_0: diag(2414, ts.DiagnosticCategory.Error, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."), + Class_0_incorrectly_extends_base_class_1: diag(2415, ts.DiagnosticCategory.Error, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."), + Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."), + Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, ts.DiagnosticCategory.Error, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."), + Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, ts.DiagnosticCategory.Error, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."), + Class_0_incorrectly_implements_interface_1: diag(2420, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."), + A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."), + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."), + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2425, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."), + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2426, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."), + Interface_name_cannot_be_0: diag(2427, ts.DiagnosticCategory.Error, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."), + All_declarations_of_0_must_have_identical_type_parameters: diag(2428, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."), + Interface_0_incorrectly_extends_interface_1: diag(2430, ts.DiagnosticCategory.Error, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."), + Enum_name_cannot_be_0: diag(2431, ts.DiagnosticCategory.Error, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."), + In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: diag(2432, ts.DiagnosticCategory.Error, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."), + A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: diag(2433, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."), + A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: diag(2434, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."), + Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: diag(2435, ts.DiagnosticCategory.Error, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."), + Ambient_module_declaration_cannot_specify_relative_module_name: diag(2436, ts.DiagnosticCategory.Error, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."), + Module_0_is_hidden_by_a_local_declaration_with_the_same_name: diag(2437, ts.DiagnosticCategory.Error, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."), + Import_name_cannot_be_0: diag(2438, ts.DiagnosticCategory.Error, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."), + Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: diag(2439, ts.DiagnosticCategory.Error, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."), + Import_declaration_conflicts_with_local_declaration_of_0: diag(2440, ts.DiagnosticCategory.Error, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: diag(2441, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."), + Types_have_separate_declarations_of_a_private_property_0: diag(2442, ts.DiagnosticCategory.Error, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."), + Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: diag(2443, ts.DiagnosticCategory.Error, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."), + Property_0_is_protected_in_type_1_but_public_in_type_2: diag(2444, ts.DiagnosticCategory.Error, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."), + Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: diag(2445, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."), + Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: diag(2446, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'."), + The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: diag(2447, ts.DiagnosticCategory.Error, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."), + Block_scoped_variable_0_used_before_its_declaration: diag(2448, ts.DiagnosticCategory.Error, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."), + Class_0_used_before_its_declaration: diag(2449, ts.DiagnosticCategory.Error, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."), + Enum_0_used_before_its_declaration: diag(2450, ts.DiagnosticCategory.Error, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."), + Cannot_redeclare_block_scoped_variable_0: diag(2451, ts.DiagnosticCategory.Error, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."), + An_enum_member_cannot_have_a_numeric_name: diag(2452, ts.DiagnosticCategory.Error, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."), + The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: diag(2453, ts.DiagnosticCategory.Error, "The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_typ_2453", "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly."), + Variable_0_is_used_before_being_assigned: diag(2454, ts.DiagnosticCategory.Error, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."), + Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: diag(2455, ts.DiagnosticCategory.Error, "Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0_2455", "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'."), + Type_alias_0_circularly_references_itself: diag(2456, ts.DiagnosticCategory.Error, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."), + Type_alias_name_cannot_be_0: diag(2457, ts.DiagnosticCategory.Error, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."), + An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, ts.DiagnosticCategory.Error, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."), + Module_0_declares_1_locally_but_it_is_not_exported: diag(2459, ts.DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_not_exported_2459", "Module '{0}' declares '{1}' locally, but it is not exported."), + Module_0_declares_1_locally_but_it_is_exported_as_2: diag(2460, ts.DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_exported_as_2_2460", "Module '{0}' declares '{1}' locally, but it is exported as '{2}'."), + Type_0_is_not_an_array_type: diag(2461, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."), + A_rest_element_must_be_last_in_a_destructuring_pattern: diag(2462, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."), + A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: diag(2463, ts.DiagnosticCategory.Error, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."), + A_computed_property_name_must_be_of_type_string_number_symbol_or_any: diag(2464, ts.DiagnosticCategory.Error, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."), + this_cannot_be_referenced_in_a_computed_property_name: diag(2465, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."), + super_cannot_be_referenced_in_a_computed_property_name: diag(2466, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."), + A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: diag(2467, ts.DiagnosticCategory.Error, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."), + Cannot_find_global_value_0: diag(2468, ts.DiagnosticCategory.Error, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."), + The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, ts.DiagnosticCategory.Error, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."), + Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: diag(2470, ts.DiagnosticCategory.Error, "Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object_2470", "'Symbol' reference does not refer to the global Symbol constructor object."), + A_computed_property_name_of_the_form_0_must_be_of_type_symbol: diag(2471, ts.DiagnosticCategory.Error, "A_computed_property_name_of_the_form_0_must_be_of_type_symbol_2471", "A computed property name of the form '{0}' must be of type 'symbol'."), + Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, ts.DiagnosticCategory.Error, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."), + Enum_declarations_must_all_be_const_or_non_const: diag(2473, ts.DiagnosticCategory.Error, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."), + const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, ts.DiagnosticCategory.Error, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."), + const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, ts.DiagnosticCategory.Error, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."), + A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, ts.DiagnosticCategory.Error, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."), + const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."), + const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: diag(2478, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."), + Property_0_does_not_exist_on_const_enum_1: diag(2479, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_const_enum_1_2479", "Property '{0}' does not exist on 'const' enum '{1}'."), + let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: diag(2480, ts.DiagnosticCategory.Error, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."), + Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: diag(2481, ts.DiagnosticCategory.Error, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."), + The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: diag(2483, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."), + Export_declaration_conflicts_with_exported_declaration_of_0: diag(2484, ts.DiagnosticCategory.Error, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."), + The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: diag(2487, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."), + Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2488, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."), + An_iterator_must_have_a_next_method: diag(2489, ts.DiagnosticCategory.Error, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."), + The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property: diag(2490, ts.DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the '{0}()' method of an iterator must have a 'value' property."), + The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: diag(2491, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."), + Cannot_redeclare_identifier_0_in_catch_clause: diag(2492, ts.DiagnosticCategory.Error, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."), + Tuple_type_0_of_length_1_has_no_element_at_index_2: diag(2493, ts.DiagnosticCategory.Error, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."), + Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: diag(2494, ts.DiagnosticCategory.Error, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."), + Type_0_is_not_an_array_type_or_a_string_type: diag(2495, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."), + The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: diag(2496, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression."), + This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: diag(2497, ts.DiagnosticCategory.Error, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."), + Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: diag(2498, ts.DiagnosticCategory.Error, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."), + An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2499, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."), + A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2500, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."), + A_rest_element_cannot_contain_a_binding_pattern: diag(2501, ts.DiagnosticCategory.Error, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."), + _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: diag(2502, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."), + Cannot_find_namespace_0: diag(2503, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."), + Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: diag(2504, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."), + A_generator_cannot_have_a_void_type_annotation: diag(2505, ts.DiagnosticCategory.Error, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."), + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: diag(2506, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."), + Type_0_is_not_a_constructor_function_type: diag(2507, ts.DiagnosticCategory.Error, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."), + No_base_constructor_has_the_specified_number_of_type_arguments: diag(2508, ts.DiagnosticCategory.Error, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."), + Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2509, ts.DiagnosticCategory.Error, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."), + Base_constructors_must_all_have_the_same_return_type: diag(2510, ts.DiagnosticCategory.Error, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."), + Cannot_create_an_instance_of_an_abstract_class: diag(2511, ts.DiagnosticCategory.Error, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."), + Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."), + Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, ts.DiagnosticCategory.Error, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."), + Classes_containing_abstract_methods_must_be_marked_abstract: diag(2514, ts.DiagnosticCategory.Error, "Classes_containing_abstract_methods_must_be_marked_abstract_2514", "Classes containing abstract methods must be marked abstract."), + Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, ts.DiagnosticCategory.Error, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."), + All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, ts.DiagnosticCategory.Error, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."), + Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, ts.DiagnosticCategory.Error, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."), + A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, ts.DiagnosticCategory.Error, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."), + An_async_iterator_must_have_a_next_method: diag(2519, ts.DiagnosticCategory.Error, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."), + Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: diag(2520, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."), + Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: diag(2521, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions_2521", "Expression resolves to variable declaration '{0}' that compiler uses to support async functions."), + The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method: diag(2522, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_usi_2522", "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method."), + yield_expressions_cannot_be_used_in_a_parameter_initializer: diag(2523, ts.DiagnosticCategory.Error, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."), + await_expressions_cannot_be_used_in_a_parameter_initializer: diag(2524, ts.DiagnosticCategory.Error, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."), + Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: diag(2525, ts.DiagnosticCategory.Error, "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", "Initializer provides no value for this binding element and the binding element has no default value."), + A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: diag(2526, ts.DiagnosticCategory.Error, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."), + The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: diag(2527, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."), + A_module_cannot_have_multiple_default_exports: diag(2528, ts.DiagnosticCategory.Error, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: diag(2529, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."), + Property_0_is_incompatible_with_index_signature: diag(2530, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."), + Object_is_possibly_null: diag(2531, ts.DiagnosticCategory.Error, "Object_is_possibly_null_2531", "Object is possibly 'null'."), + Object_is_possibly_undefined: diag(2532, ts.DiagnosticCategory.Error, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."), + Object_is_possibly_null_or_undefined: diag(2533, ts.DiagnosticCategory.Error, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."), + A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, ts.DiagnosticCategory.Error, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."), + Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, ts.DiagnosticCategory.Error, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."), + Type_0_cannot_be_used_to_index_type_1: diag(2536, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."), + Type_0_has_no_matching_index_signature_for_type_1: diag(2537, ts.DiagnosticCategory.Error, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."), + Type_0_cannot_be_used_as_an_index_type: diag(2538, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."), + Cannot_assign_to_0_because_it_is_not_a_variable: diag(2539, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."), + Cannot_assign_to_0_because_it_is_a_read_only_property: diag(2540, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."), + The_target_of_an_assignment_must_be_a_variable_or_a_property_access: diag(2541, ts.DiagnosticCategory.Error, "The_target_of_an_assignment_must_be_a_variable_or_a_property_access_2541", "The target of an assignment must be a variable or a property access."), + Index_signature_in_type_0_only_permits_reading: diag(2542, ts.DiagnosticCategory.Error, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."), + Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: diag(2543, ts.DiagnosticCategory.Error, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."), + Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: diag(2544, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."), + A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: diag(2545, ts.DiagnosticCategory.Error, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."), + Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1: diag(2546, ts.DiagnosticCategory.Error, "Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1_2546", "Property '{0}' has conflicting declarations and is inaccessible in type '{1}'."), + The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, ts.DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."), + Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"), + Cannot_find_name_0_Did_you_mean_1: diag(2552, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"), + Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, ts.DiagnosticCategory.Error, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."), + Expected_0_arguments_but_got_1: diag(2554, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."), + Expected_at_least_0_arguments_but_got_1: diag(2555, ts.DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."), + Expected_0_arguments_but_got_1_or_more: diag(2556, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_or_more_2556", "Expected {0} arguments, but got {1} or more."), + Expected_at_least_0_arguments_but_got_1_or_more: diag(2557, ts.DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_or_more_2557", "Expected at least {0} arguments, but got {1} or more."), + Expected_0_type_arguments_but_got_1: diag(2558, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."), + Type_0_has_no_properties_in_common_with_type_1: diag(2559, ts.DiagnosticCategory.Error, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."), + Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: diag(2560, ts.DiagnosticCategory.Error, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"), + Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: diag(2561, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"), + Base_class_expressions_cannot_reference_class_type_parameters: diag(2562, ts.DiagnosticCategory.Error, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."), + The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: diag(2563, ts.DiagnosticCategory.Error, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."), + Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: diag(2564, ts.DiagnosticCategory.Error, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."), + Property_0_is_used_before_being_assigned: diag(2565, ts.DiagnosticCategory.Error, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."), + A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."), + Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts.DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."), + Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."), + Object_is_of_type_unknown: diag(2571, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."), + Rest_signatures_are_incompatible: diag(2572, ts.DiagnosticCategory.Error, "Rest_signatures_are_incompatible_2572", "Rest signatures are incompatible."), + Property_0_is_incompatible_with_rest_element_type: diag(2573, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_rest_element_type_2573", "Property '{0}' is incompatible with rest element type."), + A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."), + No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts.DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."), + Property_0_is_a_static_member_of_type_1: diag(2576, ts.DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'"), + Return_type_annotation_circularly_references_itself: diag(2577, ts.DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery: diag(2581, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha: diag(2582, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha`."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2583, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to include 'dom'."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."), + Enum_type_0_circularly_references_itself: diag(2586, ts.DiagnosticCategory.Error, "Enum_type_0_circularly_references_itself_2586", "Enum type '{0}' circularly references itself."), + JSDoc_type_0_circularly_references_itself: diag(2587, ts.DiagnosticCategory.Error, "JSDoc_type_0_circularly_references_itself_2587", "JSDoc type '{0}' circularly references itself."), + Cannot_assign_to_0_because_it_is_a_constant: diag(2588, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."), + Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, ts.DiagnosticCategory.Error, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."), + Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, ts.DiagnosticCategory.Error, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_th_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node` and then add `node` to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_an_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery` and then add `jquery` to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig."), + This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts.DiagnosticCategory.Error, "This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the__2594", "This module is declared with using 'export =', and can only be used with a default import when using the '{0}' flag."), + JSX_element_attributes_type_0_may_not_be_a_union_type: diag(2600, ts.DiagnosticCategory.Error, "JSX_element_attributes_type_0_may_not_be_a_union_type_2600", "JSX element attributes type '{0}' may not be a union type."), + The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: diag(2601, ts.DiagnosticCategory.Error, "The_return_type_of_a_JSX_element_constructor_must_return_an_object_type_2601", "The return type of a JSX element constructor must return an object type."), + JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: diag(2602, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."), + Property_0_in_type_1_is_not_assignable_to_type_2: diag(2603, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."), + JSX_element_type_0_does_not_have_any_construct_or_call_signatures: diag(2604, ts.DiagnosticCategory.Error, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."), + JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: diag(2605, ts.DiagnosticCategory.Error, "JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements_2605", "JSX element type '{0}' is not a constructor function for JSX elements."), + Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: diag(2606, ts.DiagnosticCategory.Error, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."), + JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: diag(2607, ts.DiagnosticCategory.Error, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."), + The_global_type_JSX_0_may_not_have_more_than_one_property: diag(2608, ts.DiagnosticCategory.Error, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."), + JSX_spread_child_must_be_an_array_type: diag(2609, ts.DiagnosticCategory.Error, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."), + _0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property: diag(2610, ts.DiagnosticCategory.Error, "_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property_2610", "'{0}' is defined as an accessor in class '{1}', but is overridden here in '{2}' as an instance property."), + _0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor: diag(2611, ts.DiagnosticCategory.Error, "_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor_2611", "'{0}' is defined as a property in class '{1}', but is overridden here in '{2}' as an accessor."), + Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration: diag(2612, ts.DiagnosticCategory.Error, "Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_2612", "Property '{0}' will overwrite the base property in '{1}'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration."), + Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead: diag(2613, ts.DiagnosticCategory.Error, "Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead_2613", "Module '{0}' has no default export. Did you mean to use 'import { {1} } from {0}' instead?"), + Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead: diag(2614, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead_2614", "Module '{0}' has no exported member '{1}'. Did you mean to use 'import {1} from {0}' instead?"), + Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."), + A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."), + Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."), + Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, ts.DiagnosticCategory.Error, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."), + Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: diag(2654, ts.DiagnosticCategory.Error, "Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_pack_2654", "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition."), + Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: diag(2656, ts.DiagnosticCategory.Error, "Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_2656", "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition."), + JSX_expressions_must_have_one_parent_element: diag(2657, ts.DiagnosticCategory.Error, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."), + Type_0_provides_no_match_for_the_signature_1: diag(2658, ts.DiagnosticCategory.Error, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."), + super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, ts.DiagnosticCategory.Error, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."), + super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: diag(2660, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."), + Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: diag(2661, ts.DiagnosticCategory.Error, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."), + Cannot_find_name_0_Did_you_mean_the_static_member_1_0: diag(2662, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"), + Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: diag(2663, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"), + Invalid_module_name_in_augmentation_module_0_cannot_be_found: diag(2664, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."), + Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: diag(2665, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."), + Exports_and_export_assignments_are_not_permitted_in_module_augmentations: diag(2666, ts.DiagnosticCategory.Error, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."), + Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: diag(2667, ts.DiagnosticCategory.Error, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."), + export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: diag(2668, ts.DiagnosticCategory.Error, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."), + Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: diag(2669, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."), + Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: diag(2670, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."), + Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: diag(2671, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."), + Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: diag(2672, ts.DiagnosticCategory.Error, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."), + Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: diag(2673, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."), + Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: diag(2674, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."), + Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: diag(2675, ts.DiagnosticCategory.Error, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."), + Accessors_must_both_be_abstract_or_non_abstract: diag(2676, ts.DiagnosticCategory.Error, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."), + A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: diag(2677, ts.DiagnosticCategory.Error, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."), + Type_0_is_not_comparable_to_type_1: diag(2678, ts.DiagnosticCategory.Error, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."), + A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: diag(2679, ts.DiagnosticCategory.Error, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."), + A_0_parameter_must_be_the_first_parameter: diag(2680, ts.DiagnosticCategory.Error, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."), + A_constructor_cannot_have_a_this_parameter: diag(2681, ts.DiagnosticCategory.Error, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."), + get_and_set_accessor_must_have_the_same_this_type: diag(2682, ts.DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_this_type_2682", "'get' and 'set' accessor must have the same 'this' type."), + this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: diag(2683, ts.DiagnosticCategory.Error, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."), + The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: diag(2684, ts.DiagnosticCategory.Error, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."), + The_this_types_of_each_signature_are_incompatible: diag(2685, ts.DiagnosticCategory.Error, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."), + _0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: diag(2686, ts.DiagnosticCategory.Error, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."), + All_declarations_of_0_must_have_identical_modifiers: diag(2687, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."), + Cannot_find_type_definition_file_for_0: diag(2688, ts.DiagnosticCategory.Error, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."), + Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, ts.DiagnosticCategory.Error, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"), + An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, ts.DiagnosticCategory.Error, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."), + _0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, ts.DiagnosticCategory.Error, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."), + Namespace_0_has_no_exported_member_1: diag(2694, ts.DiagnosticCategory.Error, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."), + Left_side_of_comma_operator_is_unused_and_has_no_side_effects: diag(2695, ts.DiagnosticCategory.Error, "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", "Left side of comma operator is unused and has no side effects.", true), + The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, ts.DiagnosticCategory.Error, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"), + An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2697, ts.DiagnosticCategory.Error, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."), + Spread_types_may_only_be_created_from_object_types: diag(2698, ts.DiagnosticCategory.Error, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."), + Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: diag(2699, ts.DiagnosticCategory.Error, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."), + Rest_types_may_only_be_created_from_object_types: diag(2700, ts.DiagnosticCategory.Error, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."), + The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: diag(2701, ts.DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."), + _0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: diag(2702, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."), + The_operand_of_a_delete_operator_must_be_a_property_reference: diag(2703, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a 'delete' operator must be a property reference."), + The_operand_of_a_delete_operator_cannot_be_a_read_only_property: diag(2704, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a 'delete' operator cannot be a read-only property."), + An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2705, ts.DiagnosticCategory.Error, "An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_de_2705", "An async function or method in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."), + Required_type_parameters_may_not_follow_optional_type_parameters: diag(2706, ts.DiagnosticCategory.Error, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."), + Generic_type_0_requires_between_1_and_2_type_arguments: diag(2707, ts.DiagnosticCategory.Error, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."), + Cannot_use_namespace_0_as_a_value: diag(2708, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."), + Cannot_use_namespace_0_as_a_type: diag(2709, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."), + _0_are_specified_twice_The_attribute_named_0_will_be_overwritten: diag(2710, ts.DiagnosticCategory.Error, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."), + A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2711, ts.DiagnosticCategory.Error, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."), + A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2712, ts.DiagnosticCategory.Error, "A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declarat_2712", "A dynamic import call in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."), + Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: diag(2713, ts.DiagnosticCategory.Error, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", "Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}[\"{1}\"]'?"), + The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: diag(2714, ts.DiagnosticCategory.Error, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."), + Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: diag(2715, ts.DiagnosticCategory.Error, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."), + Type_parameter_0_has_a_circular_default: diag(2716, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."), + Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: diag(2717, ts.DiagnosticCategory.Error, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type. Property '{0}' must be of type '{1}', but here has type '{2}'."), + Duplicate_property_0: diag(2718, ts.DiagnosticCategory.Error, "Duplicate_property_0_2718", "Duplicate property '{0}'."), + Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: diag(2719, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."), + Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: diag(2720, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"), + Cannot_invoke_an_object_which_is_possibly_null: diag(2721, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."), + Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."), + Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."), + Module_0_has_no_exported_member_1_Did_you_mean_2: diag(2724, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_2_2724", "Module '{0}' has no exported member '{1}'. Did you mean '{2}'?"), + Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, ts.DiagnosticCategory.Error, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."), + Cannot_find_lib_definition_for_0: diag(2726, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."), + Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"), + _0_is_declared_here: diag(2728, ts.DiagnosticCategory.Message, "_0_is_declared_here_2728", "'{0}' is declared here."), + Property_0_is_used_before_its_initialization: diag(2729, ts.DiagnosticCategory.Error, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."), + An_arrow_function_cannot_have_a_this_parameter: diag(2730, ts.DiagnosticCategory.Error, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."), + Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, ts.DiagnosticCategory.Error, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."), + Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension"), + Property_0_was_also_declared_here: diag(2733, ts.DiagnosticCategory.Error, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."), + It_is_highly_likely_that_you_are_missing_a_semicolon: diag(2734, ts.DiagnosticCategory.Error, "It_is_highly_likely_that_you_are_missing_a_semicolon_2734", "It is highly likely that you are missing a semicolon."), + Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, ts.DiagnosticCategory.Error, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"), + Operator_0_cannot_be_applied_to_type_1: diag(2736, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."), + BigInt_literals_are_not_available_when_targeting_lower_than_ES2020: diag(2737, ts.DiagnosticCategory.Error, "BigInt_literals_are_not_available_when_targeting_lower_than_ES2020_2737", "BigInt literals are not available when targeting lower than ES2020."), + An_outer_value_of_this_is_shadowed_by_this_container: diag(2738, ts.DiagnosticCategory.Message, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2: diag(2739, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: diag(2740, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."), + Property_0_is_missing_in_type_1_but_required_in_type_2: diag(2741, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."), + The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2742, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."), + No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: diag(2743, ts.DiagnosticCategory.Error, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."), + Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: diag(2744, ts.DiagnosticCategory.Error, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."), + This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: diag(2745, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."), + This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: diag(2746, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."), + _0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: diag(2747, ts.DiagnosticCategory.Error, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."), + Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided: diag(2748, ts.DiagnosticCategory.Error, "Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided_2748", "Cannot access ambient const enums when the '--isolatedModules' flag is provided."), + _0_refers_to_a_value_but_is_being_used_as_a_type_here: diag(2749, ts.DiagnosticCategory.Error, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_2749", "'{0}' refers to a value, but is being used as a type here."), + The_implementation_signature_is_declared_here: diag(2750, ts.DiagnosticCategory.Error, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."), + Circularity_originates_in_type_at_this_location: diag(2751, ts.DiagnosticCategory.Error, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."), + The_first_export_default_is_here: diag(2752, ts.DiagnosticCategory.Error, "The_first_export_default_is_here_2752", "The first export default is here."), + Another_export_default_is_here: diag(2753, ts.DiagnosticCategory.Error, "Another_export_default_is_here_2753", "Another export default is here."), + super_may_not_use_type_arguments: diag(2754, ts.DiagnosticCategory.Error, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."), + No_constituent_of_type_0_is_callable: diag(2755, ts.DiagnosticCategory.Error, "No_constituent_of_type_0_is_callable_2755", "No constituent of type '{0}' is callable."), + Not_all_constituents_of_type_0_are_callable: diag(2756, ts.DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_callable_2756", "Not all constituents of type '{0}' are callable."), + Type_0_has_no_call_signatures: diag(2757, ts.DiagnosticCategory.Error, "Type_0_has_no_call_signatures_2757", "Type '{0}' has no call signatures."), + Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2758, ts.DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_2758", "Each member of the union type '{0}' has signatures, but none of those signatures are compatible with each other."), + No_constituent_of_type_0_is_constructable: diag(2759, ts.DiagnosticCategory.Error, "No_constituent_of_type_0_is_constructable_2759", "No constituent of type '{0}' is constructable."), + Not_all_constituents_of_type_0_are_constructable: diag(2760, ts.DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_constructable_2760", "Not all constituents of type '{0}' are constructable."), + Type_0_has_no_construct_signatures: diag(2761, ts.DiagnosticCategory.Error, "Type_0_has_no_construct_signatures_2761", "Type '{0}' has no construct signatures."), + Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2762, ts.DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762", "Each member of the union type '{0}' has construct signatures, but none of those signatures are compatible with each other."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0: diag(2763, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_s_2763", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0: diag(2764, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_al_2764", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0: diag(2765, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring__2765", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'."), + Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0: diag(2766, ts.DiagnosticCategory.Error, "Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_co_2766", "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'."), + The_0_property_of_an_iterator_must_be_a_method: diag(2767, ts.DiagnosticCategory.Error, "The_0_property_of_an_iterator_must_be_a_method_2767", "The '{0}' property of an iterator must be a method."), + The_0_property_of_an_async_iterator_must_be_a_method: diag(2768, ts.DiagnosticCategory.Error, "The_0_property_of_an_async_iterator_must_be_a_method_2768", "The '{0}' property of an async iterator must be a method."), + No_overload_matches_this_call: diag(2769, ts.DiagnosticCategory.Error, "No_overload_matches_this_call_2769", "No overload matches this call."), + The_last_overload_gave_the_following_error: diag(2770, ts.DiagnosticCategory.Error, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."), + The_last_overload_is_declared_here: diag(2771, ts.DiagnosticCategory.Error, "The_last_overload_is_declared_here_2771", "The last overload is declared here."), + Overload_0_of_1_2_gave_the_following_error: diag(2772, ts.DiagnosticCategory.Error, "Overload_0_of_1_2_gave_the_following_error_2772", "Overload {0} of {1}, '{2}', gave the following error."), + Did_you_forget_to_use_await: diag(2773, ts.DiagnosticCategory.Error, "Did_you_forget_to_use_await_2773", "Did you forget to use 'await'?"), + This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead: diag(2774, ts.DiagnosticCategory.Error, "This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it__2774", "This condition will always return true since the function is always defined. Did you mean to call it instead?"), + Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation: diag(2775, ts.DiagnosticCategory.Error, "Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation_2775", "Assertions require every name in the call target to be declared with an explicit type annotation."), + Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name: diag(2776, ts.DiagnosticCategory.Error, "Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name_2776", "Assertions require the call target to be an identifier or qualified name."), + The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access: diag(2777, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access_2777", "The operand of an increment or decrement operator may not be an optional property access."), + The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access: diag(2778, ts.DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access_2778", "The target of an object rest assignment may not be an optional property access."), + The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access: diag(2779, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access_2779", "The left-hand side of an assignment expression may not be an optional property access."), + The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access: diag(2780, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access_2780", "The left-hand side of a 'for...in' statement may not be an optional property access."), + The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access: diag(2781, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access_2781", "The left-hand side of a 'for...of' statement may not be an optional property access."), + _0_needs_an_explicit_type_annotation: diag(2782, ts.DiagnosticCategory.Message, "_0_needs_an_explicit_type_annotation_2782", "'{0}' needs an explicit type annotation."), + Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), + Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), + Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4006, ts.DiagnosticCategory.Error, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4008, ts.DiagnosticCategory.Error, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4010, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4012, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4014, ts.DiagnosticCategory.Error, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."), + Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, ts.DiagnosticCategory.Error, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, ts.DiagnosticCategory.Error, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."), + Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."), + Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."), + Exported_variable_0_has_or_is_using_private_name_1: diag(4025, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4026, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4027, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4028, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4029, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4030, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4031, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."), + Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4032, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Property_0_of_exported_interface_has_or_is_using_private_name_1: diag(4033, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4034, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4035, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4036, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4037, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4038, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4039, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4040, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4041, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4042, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4043, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4044, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4045, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4046, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4047, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4048, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4049, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4050, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4051, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: diag(4052, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4053, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4054, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: diag(4055, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4056, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: diag(4057, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."), + Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4058, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: diag(4059, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."), + Return_type_of_exported_function_has_or_is_using_private_name_0: diag(4060, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4061, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4062, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: diag(4063, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4064, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4065, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4066, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4067, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4068, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4069, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4070, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4071, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4072, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4073, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4074, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4075, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4076, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: diag(4077, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4078, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."), + Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, ts.DiagnosticCategory.Error, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."), + Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."), + Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, ts.DiagnosticCategory.Error, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."), + Property_0_of_exported_class_expression_may_not_be_private_or_protected: diag(4094, ts.DiagnosticCategory.Error, "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094", "Property '{0}' of exported class expression may not be private or protected."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4095, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4096, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4097, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4098, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4099, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4100, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."), + Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4101, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Method_0_of_exported_interface_has_or_is_using_private_name_1: diag(4102, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: diag(4103, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."), + The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1: diag(4104, ts.DiagnosticCategory.Error, "The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1_4104", "The type '{0}' is 'readonly' and cannot be assigned to the mutable type '{1}'."), + Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter: diag(4105, ts.DiagnosticCategory.Error, "Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter_4105", "Private or protected member '{0}' cannot be accessed on a type parameter."), + Parameter_0_of_accessor_has_or_is_using_private_name_1: diag(4106, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_private_name_1_4106", "Parameter '{0}' of accessor has or is using private name '{1}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2: diag(4107, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2_4107", "Parameter '{0}' of accessor has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4108, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4108", "Parameter '{0}' of accessor has or is using name '{1}' from external module '{2}' but cannot be named."), + Type_arguments_for_0_circularly_reference_themselves: diag(4109, ts.DiagnosticCategory.Error, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."), + Tuple_type_arguments_circularly_reference_themselves: diag(4110, ts.DiagnosticCategory.Error, "Tuple_type_arguments_circularly_reference_themselves_4110", "Tuple type arguments circularly reference themselves."), + The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."), + Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."), + File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."), + Cannot_read_file_0_Colon_1: diag(5012, ts.DiagnosticCategory.Error, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."), + Failed_to_parse_file_0_Colon_1: diag(5014, ts.DiagnosticCategory.Error, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."), + Unknown_compiler_option_0: diag(5023, ts.DiagnosticCategory.Error, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."), + Compiler_option_0_requires_a_value_of_type_1: diag(5024, ts.DiagnosticCategory.Error, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."), + Unknown_compiler_option_0_Did_you_mean_1: diag(5025, ts.DiagnosticCategory.Error, "Unknown_compiler_option_0_Did_you_mean_1_5025", "Unknown compiler option '{0}'. Did you mean '{1}'?"), + Could_not_write_file_0_Colon_1: diag(5033, ts.DiagnosticCategory.Error, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."), + Option_project_cannot_be_mixed_with_source_files_on_a_command_line: diag(5042, ts.DiagnosticCategory.Error, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."), + Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: diag(5047, ts.DiagnosticCategory.Error, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."), + Option_0_cannot_be_specified_when_option_target_is_ES3: diag(5048, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_target_is_ES3_5048", "Option '{0}' cannot be specified when option 'target' is 'ES3'."), + Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: diag(5051, ts.DiagnosticCategory.Error, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."), + Option_0_cannot_be_specified_without_specifying_option_1: diag(5052, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."), + Option_0_cannot_be_specified_with_option_1: diag(5053, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."), + A_tsconfig_json_file_is_already_defined_at_Colon_0: diag(5054, ts.DiagnosticCategory.Error, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."), + Cannot_write_file_0_because_it_would_overwrite_input_file: diag(5055, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."), + Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: diag(5056, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."), + Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."), + The_specified_path_does_not_exist_Colon_0: diag(5058, ts.DiagnosticCategory.Error, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."), + Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, ts.DiagnosticCategory.Error, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."), + Option_paths_cannot_be_used_without_specifying_baseUrl_option: diag(5060, ts.DiagnosticCategory.Error, "Option_paths_cannot_be_used_without_specifying_baseUrl_option_5060", "Option 'paths' cannot be used without specifying '--baseUrl' option."), + Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, ts.DiagnosticCategory.Error, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."), + Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: diag(5062, ts.DiagnosticCategory.Error, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."), + Substitutions_for_pattern_0_should_be_an_array: diag(5063, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."), + Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: diag(5064, ts.DiagnosticCategory.Error, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."), + File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5065, ts.DiagnosticCategory.Error, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."), + Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: diag(5066, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."), + Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(5067, ts.DiagnosticCategory.Error, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."), + Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: diag(5068, ts.DiagnosticCategory.Error, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."), + Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: diag(5069, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."), + Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy: diag(5070, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy_5070", "Option '--resolveJsonModule' cannot be specified without 'node' module resolution strategy."), + Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext: diag(5071, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_5071", "Option '--resolveJsonModule' can only be specified when module code generation is 'commonjs', 'amd', 'es2015' or 'esNext'."), + Unknown_build_option_0: diag(5072, ts.DiagnosticCategory.Error, "Unknown_build_option_0_5072", "Unknown build option '{0}'."), + Build_option_0_requires_a_value_of_type_1: diag(5073, ts.DiagnosticCategory.Error, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."), + Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified: diag(5074, ts.DiagnosticCategory.Error, "Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBui_5074", "Option '--incremental' can only be specified using tsconfig, emitting to single file or when option `--tsBuildInfoFile` is specified."), + _0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2: diag(5075, ts.DiagnosticCategory.Error, "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075", "'{0}' is assignable to the constraint of type '{1}', but '{1}' could be instantiated with a different subtype of constraint '{2}'."), + _0_and_1_operations_cannot_be_mixed_without_parentheses: diag(5076, ts.DiagnosticCategory.Error, "_0_and_1_operations_cannot_be_mixed_without_parentheses_5076", "'{0}' and '{1}' operations cannot be mixed without parentheses."), + Unknown_build_option_0_Did_you_mean_1: diag(5077, ts.DiagnosticCategory.Error, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"), + Unknown_watch_option_0: diag(5078, ts.DiagnosticCategory.Error, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."), + Unknown_watch_option_0_Did_you_mean_1: diag(5079, ts.DiagnosticCategory.Error, "Unknown_watch_option_0_Did_you_mean_1_5079", "Unknown watch option '{0}'. Did you mean '{1}'?"), + Watch_option_0_requires_a_value_of_type_1: diag(5080, ts.DiagnosticCategory.Error, "Watch_option_0_requires_a_value_of_type_1_5080", "Watch option '{0}' requires a value of type {1}."), + Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."), + Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts.DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), + Concatenate_and_emit_output_to_single_file: diag(6001, ts.DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), + Generates_corresponding_d_ts_file: diag(6002, ts.DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), + Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: diag(6003, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6003", "Specify the location where debugger should locate map files instead of generated locations."), + Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: diag(6004, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."), + Watch_input_files: diag(6005, ts.DiagnosticCategory.Message, "Watch_input_files_6005", "Watch input files."), + Redirect_output_structure_to_the_directory: diag(6006, ts.DiagnosticCategory.Message, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."), + Do_not_erase_const_enum_declarations_in_generated_code: diag(6007, ts.DiagnosticCategory.Message, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."), + Do_not_emit_outputs_if_any_errors_were_reported: diag(6008, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."), + Do_not_emit_comments_to_output: diag(6009, ts.DiagnosticCategory.Message, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."), + Do_not_emit_outputs: diag(6010, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_6010", "Do not emit outputs."), + Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: diag(6011, ts.DiagnosticCategory.Message, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."), + Skip_type_checking_of_declaration_files: diag(6012, ts.DiagnosticCategory.Message, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."), + Do_not_resolve_the_real_path_of_symlinks: diag(6013, ts.DiagnosticCategory.Message, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."), + Only_emit_d_ts_declaration_files: diag(6014, ts.DiagnosticCategory.Message, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."), + Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT: diag(6015, ts.DiagnosticCategory.Message, "Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_6015", "Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'."), + Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext: diag(6016, ts.DiagnosticCategory.Message, "Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext_6016", "Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'."), + Print_this_message: diag(6017, ts.DiagnosticCategory.Message, "Print_this_message_6017", "Print this message."), + Print_the_compiler_s_version: diag(6019, ts.DiagnosticCategory.Message, "Print_the_compiler_s_version_6019", "Print the compiler's version."), + Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: diag(6020, ts.DiagnosticCategory.Message, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."), + Syntax_Colon_0: diag(6023, ts.DiagnosticCategory.Message, "Syntax_Colon_0_6023", "Syntax: {0}"), + options: diag(6024, ts.DiagnosticCategory.Message, "options_6024", "options"), + file: diag(6025, ts.DiagnosticCategory.Message, "file_6025", "file"), + Examples_Colon_0: diag(6026, ts.DiagnosticCategory.Message, "Examples_Colon_0_6026", "Examples: {0}"), + Options_Colon: diag(6027, ts.DiagnosticCategory.Message, "Options_Colon_6027", "Options:"), + Version_0: diag(6029, ts.DiagnosticCategory.Message, "Version_0_6029", "Version {0}"), + Insert_command_line_options_and_files_from_a_file: diag(6030, ts.DiagnosticCategory.Message, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."), + Starting_compilation_in_watch_mode: diag(6031, ts.DiagnosticCategory.Message, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."), + File_change_detected_Starting_incremental_compilation: diag(6032, ts.DiagnosticCategory.Message, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."), + KIND: diag(6034, ts.DiagnosticCategory.Message, "KIND_6034", "KIND"), + FILE: diag(6035, ts.DiagnosticCategory.Message, "FILE_6035", "FILE"), + VERSION: diag(6036, ts.DiagnosticCategory.Message, "VERSION_6036", "VERSION"), + LOCATION: diag(6037, ts.DiagnosticCategory.Message, "LOCATION_6037", "LOCATION"), + DIRECTORY: diag(6038, ts.DiagnosticCategory.Message, "DIRECTORY_6038", "DIRECTORY"), + STRATEGY: diag(6039, ts.DiagnosticCategory.Message, "STRATEGY_6039", "STRATEGY"), + FILE_OR_DIRECTORY: diag(6040, ts.DiagnosticCategory.Message, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"), + Generates_corresponding_map_file: diag(6043, ts.DiagnosticCategory.Message, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."), + Compiler_option_0_expects_an_argument: diag(6044, ts.DiagnosticCategory.Error, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."), + Unterminated_quoted_string_in_response_file_0: diag(6045, ts.DiagnosticCategory.Error, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."), + Argument_for_0_option_must_be_Colon_1: diag(6046, ts.DiagnosticCategory.Error, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."), + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: diag(6048, ts.DiagnosticCategory.Error, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form or -. For example '{0}' or '{1}'."), + Unsupported_locale_0: diag(6049, ts.DiagnosticCategory.Error, "Unsupported_locale_0_6049", "Unsupported locale '{0}'."), + Unable_to_open_file_0: diag(6050, ts.DiagnosticCategory.Error, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."), + Corrupted_locale_file_0: diag(6051, ts.DiagnosticCategory.Error, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."), + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, ts.DiagnosticCategory.Message, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."), + File_0_not_found: diag(6053, ts.DiagnosticCategory.Error, "File_0_not_found_6053", "File '{0}' not found."), + File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, ts.DiagnosticCategory.Error, "File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has an unsupported extension. The only supported extensions are {1}."), + Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: diag(6055, ts.DiagnosticCategory.Message, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."), + Do_not_emit_declarations_for_code_that_has_an_internal_annotation: diag(6056, ts.DiagnosticCategory.Message, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."), + Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: diag(6058, ts.DiagnosticCategory.Message, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."), + File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: diag(6059, ts.DiagnosticCategory.Error, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."), + Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: diag(6060, ts.DiagnosticCategory.Message, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."), + NEWLINE: diag(6061, ts.DiagnosticCategory.Message, "NEWLINE_6061", "NEWLINE"), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: diag(6064, ts.DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line_6064", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'null' on command line."), + Enables_experimental_support_for_ES7_decorators: diag(6065, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."), + Enables_experimental_support_for_emitting_type_metadata_for_decorators: diag(6066, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."), + Enables_experimental_support_for_ES7_async_functions: diag(6068, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_async_functions_6068", "Enables experimental support for ES7 async functions."), + Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: diag(6069, ts.DiagnosticCategory.Message, "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)."), + Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: diag(6070, ts.DiagnosticCategory.Message, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."), + Successfully_created_a_tsconfig_json_file: diag(6071, ts.DiagnosticCategory.Message, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."), + Suppress_excess_property_checks_for_object_literals: diag(6072, ts.DiagnosticCategory.Message, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."), + Stylize_errors_and_messages_using_color_and_context_experimental: diag(6073, ts.DiagnosticCategory.Message, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."), + Do_not_report_errors_on_unused_labels: diag(6074, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."), + Report_error_when_not_all_code_paths_in_function_return_a_value: diag(6075, ts.DiagnosticCategory.Message, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."), + Report_errors_for_fallthrough_cases_in_switch_statement: diag(6076, ts.DiagnosticCategory.Message, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."), + Do_not_report_errors_on_unreachable_code: diag(6077, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."), + Disallow_inconsistently_cased_references_to_the_same_file: diag(6078, ts.DiagnosticCategory.Message, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."), + Specify_library_files_to_be_included_in_the_compilation: diag(6079, ts.DiagnosticCategory.Message, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."), + Specify_JSX_code_generation_Colon_preserve_react_native_or_react: diag(6080, ts.DiagnosticCategory.Message, "Specify_JSX_code_generation_Colon_preserve_react_native_or_react_6080", "Specify JSX code generation: 'preserve', 'react-native', or 'react'."), + File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, ts.DiagnosticCategory.Message, "File_0_has_an_unsupported_extension_so_skipping_it_6081", "File '{0}' has an unsupported extension, so skipping it."), + Only_amd_and_system_modules_are_supported_alongside_0: diag(6082, ts.DiagnosticCategory.Error, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."), + Base_directory_to_resolve_non_absolute_module_names: diag(6083, ts.DiagnosticCategory.Message, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."), + Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: diag(6084, ts.DiagnosticCategory.Message, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"), + Enable_tracing_of_the_name_resolution_process: diag(6085, ts.DiagnosticCategory.Message, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."), + Resolving_module_0_from_1: diag(6086, ts.DiagnosticCategory.Message, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"), + Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, ts.DiagnosticCategory.Message, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."), + Module_resolution_kind_is_not_specified_using_0: diag(6088, ts.DiagnosticCategory.Message, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."), + Module_name_0_was_successfully_resolved_to_1: diag(6089, ts.DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"), + Module_name_0_was_not_resolved: diag(6090, ts.DiagnosticCategory.Message, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"), + paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: diag(6091, ts.DiagnosticCategory.Message, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."), + Module_name_0_matched_pattern_1: diag(6092, ts.DiagnosticCategory.Message, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."), + Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, ts.DiagnosticCategory.Message, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."), + Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, ts.DiagnosticCategory.Message, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."), + Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1: diag(6095, ts.DiagnosticCategory.Message, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1_6095", "Loading module as file / folder, candidate module location '{0}', target file type '{1}'."), + File_0_does_not_exist: diag(6096, ts.DiagnosticCategory.Message, "File_0_does_not_exist_6096", "File '{0}' does not exist."), + File_0_exist_use_it_as_a_name_resolution_result: diag(6097, ts.DiagnosticCategory.Message, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."), + Loading_module_0_from_node_modules_folder_target_file_type_1: diag(6098, ts.DiagnosticCategory.Message, "Loading_module_0_from_node_modules_folder_target_file_type_1_6098", "Loading module '{0}' from 'node_modules' folder, target file type '{1}'."), + Found_package_json_at_0: diag(6099, ts.DiagnosticCategory.Message, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."), + package_json_does_not_have_a_0_field: diag(6100, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."), + package_json_has_0_field_1_that_references_2: diag(6101, ts.DiagnosticCategory.Message, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."), + Allow_javascript_files_to_be_compiled: diag(6102, ts.DiagnosticCategory.Message, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."), + Option_0_should_have_array_of_strings_as_a_value: diag(6103, ts.DiagnosticCategory.Error, "Option_0_should_have_array_of_strings_as_a_value_6103", "Option '{0}' should have array of strings as a value."), + Checking_if_0_is_the_longest_matching_prefix_for_1_2: diag(6104, ts.DiagnosticCategory.Message, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."), + Expected_type_of_0_field_in_package_json_to_be_1_got_2: diag(6105, ts.DiagnosticCategory.Message, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."), + baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: diag(6106, ts.DiagnosticCategory.Message, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."), + rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: diag(6107, ts.DiagnosticCategory.Message, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."), + Longest_matching_prefix_for_0_is_1: diag(6108, ts.DiagnosticCategory.Message, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."), + Loading_0_from_the_root_dir_1_candidate_location_2: diag(6109, ts.DiagnosticCategory.Message, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."), + Trying_other_entries_in_rootDirs: diag(6110, ts.DiagnosticCategory.Message, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."), + Module_resolution_using_rootDirs_has_failed: diag(6111, ts.DiagnosticCategory.Message, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."), + Do_not_emit_use_strict_directives_in_module_output: diag(6112, ts.DiagnosticCategory.Message, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."), + Enable_strict_null_checks: diag(6113, ts.DiagnosticCategory.Message, "Enable_strict_null_checks_6113", "Enable strict null checks."), + Unknown_option_excludes_Did_you_mean_exclude: diag(6114, ts.DiagnosticCategory.Error, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"), + Raise_error_on_this_expressions_with_an_implied_any_type: diag(6115, ts.DiagnosticCategory.Message, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_2: diag(6116, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"), + Resolving_using_primary_search_paths: diag(6117, ts.DiagnosticCategory.Message, "Resolving_using_primary_search_paths_6117", "Resolving using primary search paths..."), + Resolving_from_node_modules_folder: diag(6118, ts.DiagnosticCategory.Message, "Resolving_from_node_modules_folder_6118", "Resolving from node_modules folder..."), + Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: diag(6119, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"), + Type_reference_directive_0_was_not_resolved: diag(6120, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"), + Resolving_with_primary_search_path_0: diag(6121, ts.DiagnosticCategory.Message, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."), + Root_directory_cannot_be_determined_skipping_primary_search_paths: diag(6122, ts.DiagnosticCategory.Message, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: diag(6123, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"), + Type_declaration_files_to_be_included_in_compilation: diag(6124, ts.DiagnosticCategory.Message, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."), + Looking_up_in_node_modules_folder_initial_location_0: diag(6125, ts.DiagnosticCategory.Message, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."), + Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: diag(6126, ts.DiagnosticCategory.Message, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: diag(6127, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: diag(6128, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"), + Resolving_real_path_for_0_result_1: diag(6130, ts.DiagnosticCategory.Message, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."), + Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: diag(6131, ts.DiagnosticCategory.Error, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."), + File_name_0_has_a_1_extension_stripping_it: diag(6132, ts.DiagnosticCategory.Message, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."), + _0_is_declared_but_its_value_is_never_read: diag(6133, ts.DiagnosticCategory.Error, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", true), + Report_errors_on_unused_locals: diag(6134, ts.DiagnosticCategory.Message, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."), + Report_errors_on_unused_parameters: diag(6135, ts.DiagnosticCategory.Message, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."), + The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: diag(6136, ts.DiagnosticCategory.Message, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."), + Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: diag(6137, ts.DiagnosticCategory.Error, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."), + Property_0_is_declared_but_its_value_is_never_read: diag(6138, ts.DiagnosticCategory.Error, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", true), + Import_emit_helpers_from_tslib: diag(6139, ts.DiagnosticCategory.Message, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."), + Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: diag(6140, ts.DiagnosticCategory.Error, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."), + Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: diag(6141, ts.DiagnosticCategory.Message, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", "Parse in strict mode and emit \"use strict\" for each source file."), + Module_0_was_resolved_to_1_but_jsx_is_not_set: diag(6142, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."), + Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: diag(6144, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."), + Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified: diag(6145, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified_6145", "Module '{0}' was resolved as ambient module declared in '{1}' since this file was not modified."), + Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: diag(6146, ts.DiagnosticCategory.Message, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."), + Resolution_for_module_0_was_found_in_cache_from_location_1: diag(6147, ts.DiagnosticCategory.Message, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."), + Directory_0_does_not_exist_skipping_all_lookups_in_it: diag(6148, ts.DiagnosticCategory.Message, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."), + Show_diagnostic_information: diag(6149, ts.DiagnosticCategory.Message, "Show_diagnostic_information_6149", "Show diagnostic information."), + Show_verbose_diagnostic_information: diag(6150, ts.DiagnosticCategory.Message, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."), + Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: diag(6151, ts.DiagnosticCategory.Message, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."), + Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: diag(6152, ts.DiagnosticCategory.Message, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."), + Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: diag(6153, ts.DiagnosticCategory.Message, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts.transpileModule')."), + Print_names_of_generated_files_part_of_the_compilation: diag(6154, ts.DiagnosticCategory.Message, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."), + Print_names_of_files_part_of_the_compilation: diag(6155, ts.DiagnosticCategory.Message, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."), + The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: diag(6156, ts.DiagnosticCategory.Message, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"), + Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: diag(6157, ts.DiagnosticCategory.Message, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."), + Do_not_include_the_default_library_file_lib_d_ts: diag(6158, ts.DiagnosticCategory.Message, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."), + Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: diag(6159, ts.DiagnosticCategory.Message, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."), + Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: diag(6160, ts.DiagnosticCategory.Message, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."), + List_of_folders_to_include_type_definitions_from: diag(6161, ts.DiagnosticCategory.Message, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."), + Disable_size_limitations_on_JavaScript_projects: diag(6162, ts.DiagnosticCategory.Message, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."), + The_character_set_of_the_input_files: diag(6163, ts.DiagnosticCategory.Message, "The_character_set_of_the_input_files_6163", "The character set of the input files."), + Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: diag(6164, ts.DiagnosticCategory.Message, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6164", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."), + Do_not_truncate_error_messages: diag(6165, ts.DiagnosticCategory.Message, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."), + Output_directory_for_generated_declaration_files: diag(6166, ts.DiagnosticCategory.Message, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."), + A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: diag(6167, ts.DiagnosticCategory.Message, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."), + List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: diag(6168, ts.DiagnosticCategory.Message, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."), + Show_all_compiler_options: diag(6169, ts.DiagnosticCategory.Message, "Show_all_compiler_options_6169", "Show all compiler options."), + Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, ts.DiagnosticCategory.Message, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"), + Command_line_Options: diag(6171, ts.DiagnosticCategory.Message, "Command_line_Options_6171", "Command-line Options"), + Basic_Options: diag(6172, ts.DiagnosticCategory.Message, "Basic_Options_6172", "Basic Options"), + Strict_Type_Checking_Options: diag(6173, ts.DiagnosticCategory.Message, "Strict_Type_Checking_Options_6173", "Strict Type-Checking Options"), + Module_Resolution_Options: diag(6174, ts.DiagnosticCategory.Message, "Module_Resolution_Options_6174", "Module Resolution Options"), + Source_Map_Options: diag(6175, ts.DiagnosticCategory.Message, "Source_Map_Options_6175", "Source Map Options"), + Additional_Checks: diag(6176, ts.DiagnosticCategory.Message, "Additional_Checks_6176", "Additional Checks"), + Experimental_Options: diag(6177, ts.DiagnosticCategory.Message, "Experimental_Options_6177", "Experimental Options"), + Advanced_Options: diag(6178, ts.DiagnosticCategory.Message, "Advanced_Options_6178", "Advanced Options"), + Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3: diag(6179, ts.DiagnosticCategory.Message, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'."), + Enable_all_strict_type_checking_options: diag(6180, ts.DiagnosticCategory.Message, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."), + List_of_language_service_plugins: diag(6181, ts.DiagnosticCategory.Message, "List_of_language_service_plugins_6181", "List of language service plugins."), + Scoped_package_detected_looking_in_0: diag(6182, ts.DiagnosticCategory.Message, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"), + Reusing_resolution_of_module_0_to_file_1_from_old_program: diag(6183, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_to_file_1_from_old_program_6183", "Reusing resolution of module '{0}' to file '{1}' from old program."), + Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program: diag(6184, ts.DiagnosticCategory.Message, "Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program_6184", "Reusing module resolutions originating in '{0}' since resolutions are unchanged from old program."), + Disable_strict_checking_of_generic_signatures_in_function_types: diag(6185, ts.DiagnosticCategory.Message, "Disable_strict_checking_of_generic_signatures_in_function_types_6185", "Disable strict checking of generic signatures in function types."), + Enable_strict_checking_of_function_types: diag(6186, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."), + Enable_strict_checking_of_property_initialization_in_classes: diag(6187, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."), + Numeric_separators_are_not_allowed_here: diag(6188, ts.DiagnosticCategory.Error, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."), + Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, ts.DiagnosticCategory.Error, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."), + Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: diag(6191, ts.DiagnosticCategory.Message, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."), + All_imports_in_import_declaration_are_unused: diag(6192, ts.DiagnosticCategory.Error, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", true), + Found_1_error_Watching_for_file_changes: diag(6193, ts.DiagnosticCategory.Message, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."), + Found_0_errors_Watching_for_file_changes: diag(6194, ts.DiagnosticCategory.Message, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."), + Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: diag(6195, ts.DiagnosticCategory.Message, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."), + _0_is_declared_but_never_used: diag(6196, ts.DiagnosticCategory.Error, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", true), + Include_modules_imported_with_json_extension: diag(6197, ts.DiagnosticCategory.Message, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"), + All_destructured_elements_are_unused: diag(6198, ts.DiagnosticCategory.Error, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", true), + All_variables_are_unused: diag(6199, ts.DiagnosticCategory.Error, "All_variables_are_unused_6199", "All variables are unused.", true), + Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, ts.DiagnosticCategory.Error, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"), + Conflicts_are_in_this_file: diag(6201, ts.DiagnosticCategory.Message, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."), + Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, ts.DiagnosticCategory.Error, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"), + _0_was_also_declared_here: diag(6203, ts.DiagnosticCategory.Message, "_0_was_also_declared_here_6203", "'{0}' was also declared here."), + and_here: diag(6204, ts.DiagnosticCategory.Message, "and_here_6204", "and here."), + All_type_parameters_are_unused: diag(6205, ts.DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused"), + package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."), + package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."), + package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."), + package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: diag(6209, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."), + An_argument_for_0_was_not_provided: diag(6210, ts.DiagnosticCategory.Message, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."), + An_argument_matching_this_binding_pattern_was_not_provided: diag(6211, ts.DiagnosticCategory.Message, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."), + Did_you_mean_to_call_this_expression: diag(6212, ts.DiagnosticCategory.Message, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"), + Did_you_mean_to_use_new_with_this_expression: diag(6213, ts.DiagnosticCategory.Message, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"), + Enable_strict_bind_call_and_apply_methods_on_functions: diag(6214, ts.DiagnosticCategory.Message, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."), + Using_compiler_options_of_project_reference_redirect_0: diag(6215, ts.DiagnosticCategory.Message, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."), + Found_1_error: diag(6216, ts.DiagnosticCategory.Message, "Found_1_error_6216", "Found 1 error."), + Found_0_errors: diag(6217, ts.DiagnosticCategory.Message, "Found_0_errors_6217", "Found {0} errors."), + Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: diag(6218, ts.DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2_6218", "======== Module name '{0}' was successfully resolved to '{1}' with Package ID '{2}'. ========"), + Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3: diag(6219, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3_6219", "======== Type reference directive '{0}' was successfully resolved to '{1}' with Package ID '{2}', primary: {3}. ========"), + package_json_had_a_falsy_0_field: diag(6220, ts.DiagnosticCategory.Message, "package_json_had_a_falsy_0_field_6220", "'package.json' had a falsy '{0}' field."), + Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects: diag(6221, ts.DiagnosticCategory.Message, "Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects_6221", "Disable use of source files instead of declaration files from referenced projects."), + Emit_class_fields_with_Define_instead_of_Set: diag(6222, ts.DiagnosticCategory.Message, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."), + Generates_a_CPU_profile: diag(6223, ts.DiagnosticCategory.Message, "Generates_a_CPU_profile_6223", "Generates a CPU profile."), + Disable_solution_searching_for_this_project: diag(6224, ts.DiagnosticCategory.Message, "Disable_solution_searching_for_this_project_6224", "Disable solution searching for this project."), + Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_UseFsEvents_UseFsEventsOnParentDirectory: diag(6225, ts.DiagnosticCategory.Message, "Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_Dynami_6225", "Specify strategy for watching file: 'FixedPollingInterval' (default), 'PriorityPollingInterval', 'DynamicPriorityPolling', 'UseFsEvents', 'UseFsEventsOnParentDirectory'."), + Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling: diag(6226, ts.DiagnosticCategory.Message, "Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively__6226", "Specify strategy for watching directory on platforms that don't support recursive watching natively: 'UseFsEvents' (default), 'FixedPollingInterval', 'DynamicPriorityPolling'."), + Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority: diag(6227, ts.DiagnosticCategory.Message, "Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_6227", "Specify strategy for creating a polling watch when it fails to create using file system events: 'FixedInterval' (default), 'PriorityInterval', 'DynamicPriority'."), + Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively: diag(6228, ts.DiagnosticCategory.Message, "Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_supp_6228", "Synchronously call callbacks and update the state of directory watchers on platforms that don't support recursive watching natively."), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line: diag(6230, ts.DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line_6230", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'false' or 'null' on command line."), + Projects_to_reference: diag(6300, ts.DiagnosticCategory.Message, "Projects_to_reference_6300", "Projects to reference"), + Enable_project_compilation: diag(6302, ts.DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"), + Composite_projects_may_not_disable_declaration_emit: diag(6304, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."), + Output_file_0_has_not_been_built_from_source_file_1: diag(6305, ts.DiagnosticCategory.Error, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."), + Referenced_project_0_must_have_setting_composite_Colon_true: diag(6306, ts.DiagnosticCategory.Error, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", "Referenced project '{0}' must have setting \"composite\": true."), + File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, ts.DiagnosticCategory.Error, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."), + Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"), + Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"), + Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"), + Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"), + Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"), + Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"), + Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"), + Projects_in_this_build_Colon_0: diag(6355, ts.DiagnosticCategory.Message, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"), + A_non_dry_build_would_delete_the_following_files_Colon_0: diag(6356, ts.DiagnosticCategory.Message, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"), + A_non_dry_build_would_build_project_0: diag(6357, ts.DiagnosticCategory.Message, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"), + Building_project_0: diag(6358, ts.DiagnosticCategory.Message, "Building_project_0_6358", "Building project '{0}'..."), + Updating_output_timestamps_of_project_0: diag(6359, ts.DiagnosticCategory.Message, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."), + delete_this_Project_0_is_up_to_date_because_it_was_previously_built: diag(6360, ts.DiagnosticCategory.Message, "delete_this_Project_0_is_up_to_date_because_it_was_previously_built_6360", "delete this - Project '{0}' is up to date because it was previously built"), + Project_0_is_up_to_date: diag(6361, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"), + Skipping_build_of_project_0_because_its_dependency_1_has_errors: diag(6362, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"), + Project_0_can_t_be_built_because_its_dependency_1_has_errors: diag(6363, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"), + Build_one_or_more_projects_and_their_dependencies_if_out_of_date: diag(6364, ts.DiagnosticCategory.Message, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"), + Delete_the_outputs_of_all_projects: diag(6365, ts.DiagnosticCategory.Message, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects"), + Enable_verbose_logging: diag(6366, ts.DiagnosticCategory.Message, "Enable_verbose_logging_6366", "Enable verbose logging"), + Show_what_would_be_built_or_deleted_if_specified_with_clean: diag(6367, ts.DiagnosticCategory.Message, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"), + Build_all_projects_including_those_that_appear_to_be_up_to_date: diag(6368, ts.DiagnosticCategory.Message, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6368", "Build all projects, including those that appear to be up to date"), + Option_build_must_be_the_first_command_line_argument: diag(6369, ts.DiagnosticCategory.Error, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."), + Options_0_and_1_cannot_be_combined: diag(6370, ts.DiagnosticCategory.Error, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."), + Updating_unchanged_output_timestamps_of_project_0: diag(6371, ts.DiagnosticCategory.Message, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."), + Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed: diag(6372, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed_6372", "Project '{0}' is out of date because output of its dependency '{1}' has changed"), + Updating_output_of_project_0: diag(6373, ts.DiagnosticCategory.Message, "Updating_output_of_project_0_6373", "Updating output of project '{0}'..."), + A_non_dry_build_would_update_timestamps_for_output_of_project_0: diag(6374, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"), + A_non_dry_build_would_update_output_of_project_0: diag(6375, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_output_of_project_0_6375", "A non-dry build would update output of project '{0}'"), + Cannot_update_output_of_project_0_because_there_was_error_reading_file_1: diag(6376, ts.DiagnosticCategory.Message, "Cannot_update_output_of_project_0_because_there_was_error_reading_file_1_6376", "Cannot update output of project '{0}' because there was error reading file '{1}'"), + Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: diag(6377, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"), + Enable_incremental_compilation: diag(6378, ts.DiagnosticCategory.Message, "Enable_incremental_compilation_6378", "Enable incremental compilation"), + Composite_projects_may_not_disable_incremental_compilation: diag(6379, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."), + Specify_file_to_store_incremental_compilation_information: diag(6380, ts.DiagnosticCategory.Message, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"), + Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: diag(6381, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"), + Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"), + Project_0_can_t_be_built_because_its_dependency_1_was_not_built: diag(6383, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"), + Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6384, ts.DiagnosticCategory.Message, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."), + The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), + The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), + The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), + Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: diag(6503, ts.DiagnosticCategory.Message, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."), + File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: diag(6504, ts.DiagnosticCategory.Error, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"), + Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."), + Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."), + Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."), + new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: diag(7009, ts.DiagnosticCategory.Error, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: diag(7010, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."), + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7011, ts.DiagnosticCategory.Error, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."), + Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7013, ts.DiagnosticCategory.Error, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."), + Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7014, ts.DiagnosticCategory.Error, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."), + Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: diag(7015, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."), + Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: diag(7016, ts.DiagnosticCategory.Error, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: diag(7017, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."), + Object_literal_s_property_0_implicitly_has_an_1_type: diag(7018, ts.DiagnosticCategory.Error, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."), + Rest_parameter_0_implicitly_has_an_any_type: diag(7019, ts.DiagnosticCategory.Error, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."), + Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7020, ts.DiagnosticCategory.Error, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."), + _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, ts.DiagnosticCategory.Error, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."), + _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, ts.DiagnosticCategory.Error, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, ts.DiagnosticCategory.Error, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation: diag(7025, ts.DiagnosticCategory.Error, "Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_retu_7025", "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation."), + JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."), + Unreachable_code_detected: diag(7027, ts.DiagnosticCategory.Error, "Unreachable_code_detected_7027", "Unreachable code detected.", true), + Unused_label: diag(7028, ts.DiagnosticCategory.Error, "Unused_label_7028", "Unused label.", true), + Fallthrough_case_in_switch: diag(7029, ts.DiagnosticCategory.Error, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."), + Not_all_code_paths_return_a_value: diag(7030, ts.DiagnosticCategory.Error, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."), + Binding_element_0_implicitly_has_an_1_type: diag(7031, ts.DiagnosticCategory.Error, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."), + Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."), + Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."), + Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."), + Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts.DiagnosticCategory.Error, "Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_mod_7035", "Try `npm install @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"), + Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, ts.DiagnosticCategory.Error, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."), + Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, ts.DiagnosticCategory.Message, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."), + Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, ts.DiagnosticCategory.Message, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."), + Mapped_object_type_implicitly_has_an_any_template_type: diag(7039, ts.DiagnosticCategory.Error, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."), + If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: diag(7040, ts.DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}`"), + The_containing_arrow_function_captures_the_global_value_of_this: diag(7041, ts.DiagnosticCategory.Error, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."), + Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: diag(7042, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."), + Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7043, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7044, ts.DiagnosticCategory.Suggestion, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7045, ts.DiagnosticCategory.Suggestion, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: diag(7046, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."), + Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: diag(7047, ts.DiagnosticCategory.Suggestion, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: diag(7048, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: diag(7049, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."), + _0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: diag(7050, ts.DiagnosticCategory.Suggestion, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."), + Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: diag(7051, ts.DiagnosticCategory.Error, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1: diag(7052, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1_7052", "Element implicitly has an 'any' type because type '{0}' has no index signature. Did you mean to call '{1}'?"), + Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: diag(7053, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."), + No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, ts.DiagnosticCategory.Error, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: diag(7055, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."), + You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."), + You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."), + import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."), + export_can_only_be_used_in_TypeScript_files: diag(8003, ts.DiagnosticCategory.Error, "export_can_only_be_used_in_TypeScript_files_8003", "'export =' can only be used in TypeScript files."), + Type_parameter_declarations_can_only_be_used_in_TypeScript_files: diag(8004, ts.DiagnosticCategory.Error, "Type_parameter_declarations_can_only_be_used_in_TypeScript_files_8004", "Type parameter declarations can only be used in TypeScript files."), + implements_clauses_can_only_be_used_in_TypeScript_files: diag(8005, ts.DiagnosticCategory.Error, "implements_clauses_can_only_be_used_in_TypeScript_files_8005", "'implements' clauses can only be used in TypeScript files."), + _0_declarations_can_only_be_used_in_TypeScript_files: diag(8006, ts.DiagnosticCategory.Error, "_0_declarations_can_only_be_used_in_TypeScript_files_8006", "'{0}' declarations can only be used in TypeScript files."), + Type_aliases_can_only_be_used_in_TypeScript_files: diag(8008, ts.DiagnosticCategory.Error, "Type_aliases_can_only_be_used_in_TypeScript_files_8008", "Type aliases can only be used in TypeScript files."), + The_0_modifier_can_only_be_used_in_TypeScript_files: diag(8009, ts.DiagnosticCategory.Error, "The_0_modifier_can_only_be_used_in_TypeScript_files_8009", "The '{0}' modifier can only be used in TypeScript files."), + Type_annotations_can_only_be_used_in_TypeScript_files: diag(8010, ts.DiagnosticCategory.Error, "Type_annotations_can_only_be_used_in_TypeScript_files_8010", "Type annotations can only be used in TypeScript files."), + Type_arguments_can_only_be_used_in_TypeScript_files: diag(8011, ts.DiagnosticCategory.Error, "Type_arguments_can_only_be_used_in_TypeScript_files_8011", "Type arguments can only be used in TypeScript files."), + Parameter_modifiers_can_only_be_used_in_TypeScript_files: diag(8012, ts.DiagnosticCategory.Error, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."), + Non_null_assertions_can_only_be_used_in_TypeScript_files: diag(8013, ts.DiagnosticCategory.Error, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."), + Type_assertion_expressions_can_only_be_used_in_TypeScript_files: diag(8016, ts.DiagnosticCategory.Error, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."), + Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, ts.DiagnosticCategory.Error, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."), + Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."), + Report_errors_in_js_files: diag(8019, ts.DiagnosticCategory.Message, "Report_errors_in_js_files_8019", "Report errors in .js files."), + JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, ts.DiagnosticCategory.Error, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."), + JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, ts.DiagnosticCategory.Error, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."), + JSDoc_0_is_not_attached_to_a_class: diag(8022, ts.DiagnosticCategory.Error, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."), + JSDoc_0_1_does_not_match_the_extends_2_clause: diag(8023, ts.DiagnosticCategory.Error, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: diag(8024, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."), + Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: diag(8025, ts.DiagnosticCategory.Error, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one `@augments` or `@extends` tag."), + Expected_0_type_arguments_provide_these_with_an_extends_tag: diag(8026, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."), + Expected_0_1_type_arguments_provide_these_with_an_extends_tag: diag(8027, ts.DiagnosticCategory.Error, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."), + JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: diag(8028, ts.DiagnosticCategory.Error, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: diag(8029, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."), + The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, ts.DiagnosticCategory.Error, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."), + You_cannot_rename_a_module_via_a_global_import: diag(8031, ts.DiagnosticCategory.Error, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."), + Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."), + Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clause: diag(9002, ts.DiagnosticCategory.Error, "Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_clas_9002", "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause."), + class_expressions_are_not_currently_supported: diag(9003, ts.DiagnosticCategory.Error, "class_expressions_are_not_currently_supported_9003", "'class' expressions are not currently supported."), + Language_service_is_disabled: diag(9004, ts.DiagnosticCategory.Error, "Language_service_is_disabled_9004", "Language service is disabled."), + Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."), + Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."), + JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts.DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."), + JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, ts.DiagnosticCategory.Error, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."), + Expected_corresponding_JSX_closing_tag_for_0: diag(17002, ts.DiagnosticCategory.Error, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."), + JSX_attribute_expected: diag(17003, ts.DiagnosticCategory.Error, "JSX_attribute_expected_17003", "JSX attribute expected."), + Cannot_use_JSX_unless_the_jsx_flag_is_provided: diag(17004, ts.DiagnosticCategory.Error, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."), + A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: diag(17005, ts.DiagnosticCategory.Error, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."), + An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17006, ts.DiagnosticCategory.Error, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17007, ts.DiagnosticCategory.Error, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + JSX_element_0_has_no_corresponding_closing_tag: diag(17008, ts.DiagnosticCategory.Error, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."), + super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: diag(17009, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."), + Unknown_type_acquisition_option_0: diag(17010, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."), + super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: diag(17011, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."), + _0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: diag(17012, ts.DiagnosticCategory.Error, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"), + Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, ts.DiagnosticCategory.Error, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."), + JSX_fragment_has_no_corresponding_closing_tag: diag(17014, ts.DiagnosticCategory.Error, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."), + Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, ts.DiagnosticCategory.Error, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."), + JSX_fragment_is_not_supported_when_using_jsxFactory: diag(17016, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_jsxFactory_17016", "JSX fragment is not supported when using --jsxFactory"), + JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma: diag(17017, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma_17017", "JSX fragment is not supported when using an inline JSX factory pragma"), + Unknown_type_acquisition_option_0_Did_you_mean_1: diag(17018, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"), + Circularity_detected_while_resolving_configuration_Colon_0: diag(18000, ts.DiagnosticCategory.Error, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"), + A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not: diag(18001, ts.DiagnosticCategory.Error, "A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not_18001", "A path in an 'extends' option must be relative or rooted, but '{0}' is not."), + The_files_list_in_config_file_0_is_empty: diag(18002, ts.DiagnosticCategory.Error, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."), + No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: diag(18003, ts.DiagnosticCategory.Error, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."), + File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module: diag(80001, ts.DiagnosticCategory.Suggestion, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module_80001", "File is a CommonJS module; it may be converted to an ES6 module."), + This_constructor_function_may_be_converted_to_a_class_declaration: diag(80002, ts.DiagnosticCategory.Suggestion, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."), + Import_may_be_converted_to_a_default_import: diag(80003, ts.DiagnosticCategory.Suggestion, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."), + JSDoc_types_may_be_moved_to_TypeScript_types: diag(80004, ts.DiagnosticCategory.Suggestion, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."), + require_call_may_be_converted_to_an_import: diag(80005, ts.DiagnosticCategory.Suggestion, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."), + This_may_be_converted_to_an_async_function: diag(80006, ts.DiagnosticCategory.Suggestion, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."), + await_has_no_effect_on_the_type_of_this_expression: diag(80007, ts.DiagnosticCategory.Suggestion, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."), + Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, ts.DiagnosticCategory.Suggestion, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."), + Add_missing_super_call: diag(90001, ts.DiagnosticCategory.Message, "Add_missing_super_call_90001", "Add missing 'super()' call"), + Make_super_call_the_first_statement_in_the_constructor: diag(90002, ts.DiagnosticCategory.Message, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"), + Change_extends_to_implements: diag(90003, ts.DiagnosticCategory.Message, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"), + Remove_unused_declaration_for_Colon_0: diag(90004, ts.DiagnosticCategory.Message, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"), + Remove_import_from_0: diag(90005, ts.DiagnosticCategory.Message, "Remove_import_from_0_90005", "Remove import from '{0}'"), + Implement_interface_0: diag(90006, ts.DiagnosticCategory.Message, "Implement_interface_0_90006", "Implement interface '{0}'"), + Implement_inherited_abstract_class: diag(90007, ts.DiagnosticCategory.Message, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"), + Add_0_to_unresolved_variable: diag(90008, ts.DiagnosticCategory.Message, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"), + Remove_destructuring: diag(90009, ts.DiagnosticCategory.Message, "Remove_destructuring_90009", "Remove destructuring"), + Remove_variable_statement: diag(90010, ts.DiagnosticCategory.Message, "Remove_variable_statement_90010", "Remove variable statement"), + Remove_template_tag: diag(90011, ts.DiagnosticCategory.Message, "Remove_template_tag_90011", "Remove template tag"), + Remove_type_parameters: diag(90012, ts.DiagnosticCategory.Message, "Remove_type_parameters_90012", "Remove type parameters"), + Import_0_from_module_1: diag(90013, ts.DiagnosticCategory.Message, "Import_0_from_module_1_90013", "Import '{0}' from module \"{1}\""), + Change_0_to_1: diag(90014, ts.DiagnosticCategory.Message, "Change_0_to_1_90014", "Change '{0}' to '{1}'"), + Add_0_to_existing_import_declaration_from_1: diag(90015, ts.DiagnosticCategory.Message, "Add_0_to_existing_import_declaration_from_1_90015", "Add '{0}' to existing import declaration from \"{1}\""), + Declare_property_0: diag(90016, ts.DiagnosticCategory.Message, "Declare_property_0_90016", "Declare property '{0}'"), + Add_index_signature_for_property_0: diag(90017, ts.DiagnosticCategory.Message, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"), + Disable_checking_for_this_file: diag(90018, ts.DiagnosticCategory.Message, "Disable_checking_for_this_file_90018", "Disable checking for this file"), + Ignore_this_error_message: diag(90019, ts.DiagnosticCategory.Message, "Ignore_this_error_message_90019", "Ignore this error message"), + Initialize_property_0_in_the_constructor: diag(90020, ts.DiagnosticCategory.Message, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"), + Initialize_static_property_0: diag(90021, ts.DiagnosticCategory.Message, "Initialize_static_property_0_90021", "Initialize static property '{0}'"), + Change_spelling_to_0: diag(90022, ts.DiagnosticCategory.Message, "Change_spelling_to_0_90022", "Change spelling to '{0}'"), + Declare_method_0: diag(90023, ts.DiagnosticCategory.Message, "Declare_method_0_90023", "Declare method '{0}'"), + Declare_static_method_0: diag(90024, ts.DiagnosticCategory.Message, "Declare_static_method_0_90024", "Declare static method '{0}'"), + Prefix_0_with_an_underscore: diag(90025, ts.DiagnosticCategory.Message, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"), + Rewrite_as_the_indexed_access_type_0: diag(90026, ts.DiagnosticCategory.Message, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"), + Declare_static_property_0: diag(90027, ts.DiagnosticCategory.Message, "Declare_static_property_0_90027", "Declare static property '{0}'"), + Call_decorator_expression: diag(90028, ts.DiagnosticCategory.Message, "Call_decorator_expression_90028", "Call decorator expression"), + Add_async_modifier_to_containing_function: diag(90029, ts.DiagnosticCategory.Message, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"), + Replace_infer_0_with_unknown: diag(90030, ts.DiagnosticCategory.Message, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"), + Replace_all_unused_infer_with_unknown: diag(90031, ts.DiagnosticCategory.Message, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"), + Import_default_0_from_module_1: diag(90032, ts.DiagnosticCategory.Message, "Import_default_0_from_module_1_90032", "Import default '{0}' from module \"{1}\""), + Add_default_import_0_to_existing_import_declaration_from_1: diag(90033, ts.DiagnosticCategory.Message, "Add_default_import_0_to_existing_import_declaration_from_1_90033", "Add default import '{0}' to existing import declaration from \"{1}\""), + Add_parameter_name: diag(90034, ts.DiagnosticCategory.Message, "Add_parameter_name_90034", "Add parameter name"), + Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."), + Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"), + Convert_function_0_to_class: diag(95002, ts.DiagnosticCategory.Message, "Convert_function_0_to_class_95002", "Convert function '{0}' to class"), + Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"), + Extract_function: diag(95005, ts.DiagnosticCategory.Message, "Extract_function_95005", "Extract function"), + Extract_constant: diag(95006, ts.DiagnosticCategory.Message, "Extract_constant_95006", "Extract constant"), + Extract_to_0_in_enclosing_scope: diag(95007, ts.DiagnosticCategory.Message, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"), + Extract_to_0_in_1_scope: diag(95008, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"), + Annotate_with_type_from_JSDoc: diag(95009, ts.DiagnosticCategory.Message, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"), + Annotate_with_types_from_JSDoc: diag(95010, ts.DiagnosticCategory.Message, "Annotate_with_types_from_JSDoc_95010", "Annotate with types from JSDoc"), + Infer_type_of_0_from_usage: diag(95011, ts.DiagnosticCategory.Message, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"), + Infer_parameter_types_from_usage: diag(95012, ts.DiagnosticCategory.Message, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"), + Convert_to_default_import: diag(95013, ts.DiagnosticCategory.Message, "Convert_to_default_import_95013", "Convert to default import"), + Install_0: diag(95014, ts.DiagnosticCategory.Message, "Install_0_95014", "Install '{0}'"), + Replace_import_with_0: diag(95015, ts.DiagnosticCategory.Message, "Replace_import_with_0_95015", "Replace import with '{0}'."), + Use_synthetic_default_member: diag(95016, ts.DiagnosticCategory.Message, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."), + Convert_to_ES6_module: diag(95017, ts.DiagnosticCategory.Message, "Convert_to_ES6_module_95017", "Convert to ES6 module"), + Add_undefined_type_to_property_0: diag(95018, ts.DiagnosticCategory.Message, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"), + Add_initializer_to_property_0: diag(95019, ts.DiagnosticCategory.Message, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"), + Add_definite_assignment_assertion_to_property_0: diag(95020, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"), + Add_all_missing_members: diag(95022, ts.DiagnosticCategory.Message, "Add_all_missing_members_95022", "Add all missing members"), + Infer_all_types_from_usage: diag(95023, ts.DiagnosticCategory.Message, "Infer_all_types_from_usage_95023", "Infer all types from usage"), + Delete_all_unused_declarations: diag(95024, ts.DiagnosticCategory.Message, "Delete_all_unused_declarations_95024", "Delete all unused declarations"), + Prefix_all_unused_declarations_with_where_possible: diag(95025, ts.DiagnosticCategory.Message, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"), + Fix_all_detected_spelling_errors: diag(95026, ts.DiagnosticCategory.Message, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"), + Add_initializers_to_all_uninitialized_properties: diag(95027, ts.DiagnosticCategory.Message, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"), + Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"), + Add_undefined_type_to_all_uninitialized_properties: diag(95029, ts.DiagnosticCategory.Message, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"), + Change_all_jsdoc_style_types_to_TypeScript: diag(95030, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"), + Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: diag(95031, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"), + Implement_all_unimplemented_interfaces: diag(95032, ts.DiagnosticCategory.Message, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"), + Install_all_missing_types_packages: diag(95033, ts.DiagnosticCategory.Message, "Install_all_missing_types_packages_95033", "Install all missing types packages"), + Rewrite_all_as_indexed_access_types: diag(95034, ts.DiagnosticCategory.Message, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"), + Convert_all_to_default_imports: diag(95035, ts.DiagnosticCategory.Message, "Convert_all_to_default_imports_95035", "Convert all to default imports"), + Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, ts.DiagnosticCategory.Message, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"), + Add_qualifier_to_all_unresolved_variables_matching_a_member_name: diag(95037, ts.DiagnosticCategory.Message, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"), + Change_all_extended_interfaces_to_implements: diag(95038, ts.DiagnosticCategory.Message, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"), + Add_all_missing_super_calls: diag(95039, ts.DiagnosticCategory.Message, "Add_all_missing_super_calls_95039", "Add all missing super calls"), + Implement_all_inherited_abstract_classes: diag(95040, ts.DiagnosticCategory.Message, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"), + Add_all_missing_async_modifiers: diag(95041, ts.DiagnosticCategory.Message, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"), + Add_ts_ignore_to_all_error_messages: diag(95042, ts.DiagnosticCategory.Message, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"), + Annotate_everything_with_types_from_JSDoc: diag(95043, ts.DiagnosticCategory.Message, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"), + Add_to_all_uncalled_decorators: diag(95044, ts.DiagnosticCategory.Message, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"), + Convert_all_constructor_functions_to_classes: diag(95045, ts.DiagnosticCategory.Message, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"), + Generate_get_and_set_accessors: diag(95046, ts.DiagnosticCategory.Message, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"), + Convert_require_to_import: diag(95047, ts.DiagnosticCategory.Message, "Convert_require_to_import_95047", "Convert 'require' to 'import'"), + Convert_all_require_to_import: diag(95048, ts.DiagnosticCategory.Message, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"), + Move_to_a_new_file: diag(95049, ts.DiagnosticCategory.Message, "Move_to_a_new_file_95049", "Move to a new file"), + Remove_unreachable_code: diag(95050, ts.DiagnosticCategory.Message, "Remove_unreachable_code_95050", "Remove unreachable code"), + Remove_all_unreachable_code: diag(95051, ts.DiagnosticCategory.Message, "Remove_all_unreachable_code_95051", "Remove all unreachable code"), + Add_missing_typeof: diag(95052, ts.DiagnosticCategory.Message, "Add_missing_typeof_95052", "Add missing 'typeof'"), + Remove_unused_label: diag(95053, ts.DiagnosticCategory.Message, "Remove_unused_label_95053", "Remove unused label"), + Remove_all_unused_labels: diag(95054, ts.DiagnosticCategory.Message, "Remove_all_unused_labels_95054", "Remove all unused labels"), + Convert_0_to_mapped_object_type: diag(95055, ts.DiagnosticCategory.Message, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"), + Convert_namespace_import_to_named_imports: diag(95056, ts.DiagnosticCategory.Message, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"), + Convert_named_imports_to_namespace_import: diag(95057, ts.DiagnosticCategory.Message, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"), + Add_or_remove_braces_in_an_arrow_function: diag(95058, ts.DiagnosticCategory.Message, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"), + Add_braces_to_arrow_function: diag(95059, ts.DiagnosticCategory.Message, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"), + Remove_braces_from_arrow_function: diag(95060, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"), + Convert_default_export_to_named_export: diag(95061, ts.DiagnosticCategory.Message, "Convert_default_export_to_named_export_95061", "Convert default export to named export"), + Convert_named_export_to_default_export: diag(95062, ts.DiagnosticCategory.Message, "Convert_named_export_to_default_export_95062", "Convert named export to default export"), + Add_missing_enum_member_0: diag(95063, ts.DiagnosticCategory.Message, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"), + Add_all_missing_imports: diag(95064, ts.DiagnosticCategory.Message, "Add_all_missing_imports_95064", "Add all missing imports"), + Convert_to_async_function: diag(95065, ts.DiagnosticCategory.Message, "Convert_to_async_function_95065", "Convert to async function"), + Convert_all_to_async_functions: diag(95066, ts.DiagnosticCategory.Message, "Convert_all_to_async_functions_95066", "Convert all to async functions"), + Add_unknown_conversion_for_non_overlapping_types: diag(95069, ts.DiagnosticCategory.Message, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"), + Add_unknown_to_all_conversions_of_non_overlapping_types: diag(95070, ts.DiagnosticCategory.Message, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"), + Add_missing_new_operator_to_call: diag(95071, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"), + Add_missing_new_operator_to_all_calls: diag(95072, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"), + Add_names_to_all_parameters_without_names: diag(95073, ts.DiagnosticCategory.Message, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"), + Enable_the_experimentalDecorators_option_in_your_configuration_file: diag(95074, ts.DiagnosticCategory.Message, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"), + Convert_parameters_to_destructured_object: diag(95075, ts.DiagnosticCategory.Message, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"), + Allow_accessing_UMD_globals_from_modules: diag(95076, ts.DiagnosticCategory.Message, "Allow_accessing_UMD_globals_from_modules_95076", "Allow accessing UMD globals from modules."), + Extract_type: diag(95077, ts.DiagnosticCategory.Message, "Extract_type_95077", "Extract type"), + Extract_to_type_alias: diag(95078, ts.DiagnosticCategory.Message, "Extract_to_type_alias_95078", "Extract to type alias"), + Extract_to_typedef: diag(95079, ts.DiagnosticCategory.Message, "Extract_to_typedef_95079", "Extract to typedef"), + Infer_this_type_of_0_from_usage: diag(95080, ts.DiagnosticCategory.Message, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"), + Add_const_to_unresolved_variable: diag(95081, ts.DiagnosticCategory.Message, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"), + Add_const_to_all_unresolved_variables: diag(95082, ts.DiagnosticCategory.Message, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"), + Add_await: diag(95083, ts.DiagnosticCategory.Message, "Add_await_95083", "Add 'await'"), + Add_await_to_initializer_for_0: diag(95084, ts.DiagnosticCategory.Message, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"), + Fix_all_expressions_possibly_missing_await: diag(95085, ts.DiagnosticCategory.Message, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"), + Remove_unnecessary_await: diag(95086, ts.DiagnosticCategory.Message, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"), + Remove_all_unnecessary_uses_of_await: diag(95087, ts.DiagnosticCategory.Message, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"), + Enable_the_jsx_flag_in_your_configuration_file: diag(95088, ts.DiagnosticCategory.Message, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"), + Add_await_to_initializers: diag(95089, ts.DiagnosticCategory.Message, "Add_await_to_initializers_95089", "Add 'await' to initializers"), + Extract_to_interface: diag(95090, ts.DiagnosticCategory.Message, "Extract_to_interface_95090", "Extract to interface"), + Convert_to_a_bigint_numeric_literal: diag(95091, ts.DiagnosticCategory.Message, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"), + Convert_all_to_bigint_numeric_literals: diag(95092, ts.DiagnosticCategory.Message, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"), + Convert_const_to_let: diag(95093, ts.DiagnosticCategory.Message, "Convert_const_to_let_95093", "Convert 'const' to 'let'"), + Prefix_with_declare: diag(95094, ts.DiagnosticCategory.Message, "Prefix_with_declare_95094", "Prefix with 'declare'"), + Prefix_all_incorrect_property_declarations_with_declare: diag(95095, ts.DiagnosticCategory.Message, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"), + Convert_to_template_string: diag(95096, ts.DiagnosticCategory.Message, "Convert_to_template_string_95096", "Convert to template string"), + Add_export_to_make_this_file_into_a_module: diag(95097, ts.DiagnosticCategory.Message, "Add_export_to_make_this_file_into_a_module_95097", "Add 'export {}' to make this file into a module"), + Set_the_target_option_in_your_configuration_file_to_0: diag(95098, ts.DiagnosticCategory.Message, "Set_the_target_option_in_your_configuration_file_to_0_95098", "Set the 'target' option in your configuration file to '{0}'"), + Set_the_module_option_in_your_configuration_file_to_0: diag(95099, ts.DiagnosticCategory.Message, "Set_the_module_option_in_your_configuration_file_to_0_95099", "Set the 'module' option in your configuration file to '{0}'"), + No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), + Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), + JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), + Private_identifiers_cannot_be_used_as_parameters: diag(18009, ts.DiagnosticCategory.Error, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters"), + An_accessibility_modifier_cannot_be_used_with_a_private_identifier: diag(18010, ts.DiagnosticCategory.Error, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."), + The_operand_of_a_delete_operator_cannot_be_a_private_identifier: diag(18011, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."), + constructor_is_a_reserved_word: diag(18012, ts.DiagnosticCategory.Error, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."), + Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier: diag(18013, ts.DiagnosticCategory.Error, "Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier_18013", "Property '{0}' is not accessible outside class '{1}' because it has a private identifier."), + The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling: diag(18014, ts.DiagnosticCategory.Error, "The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_priv_18014", "The property '{0}' cannot be accessed on type '{1}' within this class because it is shadowed by another private identifier with the same spelling."), + Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2: diag(18015, ts.DiagnosticCategory.Error, "Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2_18015", "Property '{0}' in type '{1}' refers to a different member that cannot be accessed from within type '{2}'."), + Private_identifiers_are_not_allowed_outside_class_bodies: diag(18016, ts.DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."), + The_shadowing_declaration_of_0_is_defined_here: diag(18017, ts.DiagnosticCategory.Error, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"), + The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: diag(18018, ts.DiagnosticCategory.Error, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"), + _0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier"), + A_method_cannot_be_named_with_a_private_identifier: diag(18022, ts.DiagnosticCategory.Error, "A_method_cannot_be_named_with_a_private_identifier_18022", "A method cannot be named with a private identifier."), + An_accessor_cannot_be_named_with_a_private_identifier: diag(18023, ts.DiagnosticCategory.Error, "An_accessor_cannot_be_named_with_a_private_identifier_18023", "An accessor cannot be named with a private identifier."), + An_enum_member_cannot_be_named_with_a_private_identifier: diag(18024, ts.DiagnosticCategory.Error, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."), + can_only_be_used_at_the_start_of_a_file: diag(18026, ts.DiagnosticCategory.Error, "can_only_be_used_at_the_start_of_a_file_18026", "'#!' can only be used at the start of a file."), + Compiler_reserves_name_0_when_emitting_private_identifier_downlevel: diag(18027, ts.DiagnosticCategory.Error, "Compiler_reserves_name_0_when_emitting_private_identifier_downlevel_18027", "Compiler reserves name '{0}' when emitting private identifier downlevel."), + Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18028, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher_18028", "Private identifiers are only available when targeting ECMAScript 2015 and higher."), + Private_identifiers_are_not_allowed_in_variable_declarations: diag(18029, ts.DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_in_variable_declarations_18029", "Private identifiers are not allowed in variable declarations."), + An_optional_chain_cannot_contain_private_identifiers: diag(18030, ts.DiagnosticCategory.Error, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."), + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + var _a; + function tokenIsIdentifierOrKeyword(token) { + return token >= 75; + } + ts.tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword; + function tokenIsIdentifierOrKeywordOrGreaterThan(token) { + return token === 31 || tokenIsIdentifierOrKeyword(token); + } + ts.tokenIsIdentifierOrKeywordOrGreaterThan = tokenIsIdentifierOrKeywordOrGreaterThan; + var textToKeywordObj = (_a = { + abstract: 122, + any: 125, + as: 123, + asserts: 124, + bigint: 151, + boolean: 128, + break: 77, + case: 78, + catch: 79, + class: 80, + continue: 82, + const: 81 + }, + _a["" + "constructor"] = 129, + _a.debugger = 83, + _a.declare = 130, + _a.default = 84, + _a.delete = 85, + _a.do = 86, + _a.else = 87, + _a.enum = 88, + _a.export = 89, + _a.extends = 90, + _a.false = 91, + _a.finally = 92, + _a.for = 93, + _a.from = 149, + _a.function = 94, + _a.get = 131, + _a.if = 95, + _a.implements = 113, + _a.import = 96, + _a.in = 97, + _a.infer = 132, + _a.instanceof = 98, + _a.interface = 114, + _a.is = 133, + _a.keyof = 134, + _a.let = 115, + _a.module = 135, + _a.namespace = 136, + _a.never = 137, + _a.new = 99, + _a.null = 100, + _a.number = 140, + _a.object = 141, + _a.package = 116, + _a.private = 117, + _a.protected = 118, + _a.public = 119, + _a.readonly = 138, + _a.require = 139, + _a.global = 150, + _a.return = 101, + _a.set = 142, + _a.static = 120, + _a.string = 143, + _a.super = 102, + _a.switch = 103, + _a.symbol = 144, + _a.this = 104, + _a.throw = 105, + _a.true = 106, + _a.try = 107, + _a.type = 145, + _a.typeof = 108, + _a.undefined = 146, + _a.unique = 147, + _a.unknown = 148, + _a.var = 109, + _a.void = 110, + _a.while = 111, + _a.with = 112, + _a.yield = 121, + _a.async = 126, + _a.await = 127, + _a.of = 152, + _a); + var textToKeyword = ts.createMapFromTemplate(textToKeywordObj); + var textToToken = ts.createMapFromTemplate(__assign(__assign({}, textToKeywordObj), { "{": 18, "}": 19, "(": 20, ")": 21, "[": 22, "]": 23, ".": 24, "...": 25, ";": 26, ",": 27, "<": 29, ">": 31, "<=": 32, ">=": 33, "==": 34, "!=": 35, "===": 36, "!==": 37, "=>": 38, "+": 39, "-": 40, "**": 42, "*": 41, "/": 43, "%": 44, "++": 45, "--": 46, "<<": 47, ">": 48, ">>>": 49, "&": 50, "|": 51, "^": 52, "!": 53, "~": 54, "&&": 55, "||": 56, "?": 57, "??": 60, "?.": 28, ":": 58, "=": 62, "+=": 63, "-=": 64, "*=": 65, "**=": 66, "/=": 67, "%=": 68, "<<=": 69, ">>=": 70, ">>>=": 71, "&=": 72, "|=": 73, "^=": 74, "@": 59, "`": 61 })); + var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2208, 2228, 2230, 2237, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69376, 69404, 69415, 69415, 69424, 69445, 69600, 69622, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70751, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71680, 71723, 71840, 71903, 71935, 71935, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 123136, 123180, 123191, 123197, 123214, 123214, 123584, 123627, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101]; + var unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2208, 2228, 2230, 2237, 2259, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3328, 3331, 3333, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7673, 7675, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43047, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69376, 69404, 69415, 69415, 69424, 69456, 69600, 69622, 69632, 69702, 69734, 69743, 69759, 69818, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69958, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70096, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70206, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70751, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71680, 71738, 71840, 71913, 71935, 71935, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123584, 123641, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]; + function lookupInUnicodeMap(code, map) { + if (code < map[0]) { + return false; + } + var lo = 0; + var hi = map.length; + var mid; + while (lo + 1 < hi) { + mid = lo + (hi - lo) / 2; + mid -= mid % 2; + if (map[mid] <= code && code <= map[mid + 1]) { + return true; + } + if (code < map[mid]) { + hi = mid; + } + else { + lo = mid + 2; + } + } + return false; + } + function isUnicodeIdentifierStart(code, languageVersion) { + return languageVersion >= 2 ? + lookupInUnicodeMap(code, unicodeESNextIdentifierStart) : + languageVersion === 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : + lookupInUnicodeMap(code, unicodeES3IdentifierStart); + } + ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart; + function isUnicodeIdentifierPart(code, languageVersion) { + return languageVersion >= 2 ? + lookupInUnicodeMap(code, unicodeESNextIdentifierPart) : + languageVersion === 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : + lookupInUnicodeMap(code, unicodeES3IdentifierPart); + } + function makeReverseMap(source) { + var result = []; + source.forEach(function (value, name) { + result[value] = name; + }); + return result; + } + var tokenStrings = makeReverseMap(textToToken); + function tokenToString(t) { + return tokenStrings[t]; + } + ts.tokenToString = tokenToString; + function stringToToken(s) { + return textToToken.get(s); + } + ts.stringToToken = stringToToken; + function computeLineStarts(text) { + var result = new Array(); + var pos = 0; + var lineStart = 0; + while (pos < text.length) { + var ch = text.charCodeAt(pos); + pos++; + switch (ch) { + case 13: + if (text.charCodeAt(pos) === 10) { + pos++; + } + case 10: + result.push(lineStart); + lineStart = pos; + break; + default: + if (ch > 127 && isLineBreak(ch)) { + result.push(lineStart); + lineStart = pos; + } + break; + } + } + result.push(lineStart); + return result; + } + ts.computeLineStarts = computeLineStarts; + function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) { + return sourceFile.getPositionOfLineAndCharacter ? + sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) : + computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits); + } + ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter; + function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) { + if (line < 0 || line >= lineStarts.length) { + if (allowEdits) { + line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line; + } + else { + ts.Debug.fail("Bad line number. Line: " + line + ", lineStarts.length: " + lineStarts.length + " , line map is correct? " + (debugText !== undefined ? ts.arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown")); + } + } + var res = lineStarts[line] + character; + if (allowEdits) { + return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res; + } + if (line < lineStarts.length - 1) { + ts.Debug.assert(res < lineStarts[line + 1]); + } + else if (debugText !== undefined) { + ts.Debug.assert(res <= debugText.length); + } + return res; + } + ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter; + function getLineStarts(sourceFile) { + return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text)); + } + ts.getLineStarts = getLineStarts; + function computeLineAndCharacterOfPosition(lineStarts, position) { + var lineNumber = ts.binarySearch(lineStarts, position, ts.identity, ts.compareValues); + if (lineNumber < 0) { + lineNumber = ~lineNumber - 1; + ts.Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file"); + } + return { + line: lineNumber, + character: position - lineStarts[lineNumber] + }; + } + ts.computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition; + function getLineAndCharacterOfPosition(sourceFile, position) { + return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position); + } + ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition; + function isWhiteSpaceLike(ch) { + return isWhiteSpaceSingleLine(ch) || isLineBreak(ch); + } + ts.isWhiteSpaceLike = isWhiteSpaceLike; + function isWhiteSpaceSingleLine(ch) { + return ch === 32 || + ch === 9 || + ch === 11 || + ch === 12 || + ch === 160 || + ch === 133 || + ch === 5760 || + ch >= 8192 && ch <= 8203 || + ch === 8239 || + ch === 8287 || + ch === 12288 || + ch === 65279; + } + ts.isWhiteSpaceSingleLine = isWhiteSpaceSingleLine; + function isLineBreak(ch) { + return ch === 10 || + ch === 13 || + ch === 8232 || + ch === 8233; + } + ts.isLineBreak = isLineBreak; + function isDigit(ch) { + return ch >= 48 && ch <= 57; + } + function isOctalDigit(ch) { + return ch >= 48 && ch <= 55; + } + ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + case 10: + case 9: + case 11: + case 12: + case 32: + case 47: + case 60: + case 124: + case 61: + case 62: + return true; + case 35: + return pos === 0; + default: + return ch > 127; + } + } + ts.couldStartTrivia = couldStartTrivia; + function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments) { + if (stopAtComments === void 0) { stopAtComments = false; } + if (ts.positionIsSynthesized(pos)) { + return pos; + } + while (true) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + if (text.charCodeAt(pos + 1) === 10) { + pos++; + } + case 10: + pos++; + if (stopAfterLineBreak) { + return pos; + } + continue; + case 9: + case 11: + case 12: + case 32: + pos++; + continue; + case 47: + if (stopAtComments) { + break; + } + if (text.charCodeAt(pos + 1) === 47) { + pos += 2; + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + continue; + } + if (text.charCodeAt(pos + 1) === 42) { + pos += 2; + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + break; + } + pos++; + } + continue; + } + break; + case 60: + case 124: + case 61: + case 62: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos); + continue; + } + break; + case 35: + if (pos === 0 && isShebangTrivia(text, pos)) { + pos = scanShebangTrivia(text, pos); + continue; + } + break; + default: + if (ch > 127 && (isWhiteSpaceLike(ch))) { + pos++; + continue; + } + break; + } + return pos; + } + } + ts.skipTrivia = skipTrivia; + var mergeConflictMarkerLength = "<<<<<<<".length; + function isConflictMarkerTrivia(text, pos) { + ts.Debug.assert(pos >= 0); + if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) { + var ch = text.charCodeAt(pos); + if ((pos + mergeConflictMarkerLength) < text.length) { + for (var i = 0; i < mergeConflictMarkerLength; i++) { + if (text.charCodeAt(pos + i) !== ch) { + return false; + } + } + return ch === 61 || + text.charCodeAt(pos + mergeConflictMarkerLength) === 32; + } + } + return false; + } + function scanConflictMarkerTrivia(text, pos, error) { + if (error) { + error(ts.Diagnostics.Merge_conflict_marker_encountered, pos, mergeConflictMarkerLength); + } + var ch = text.charCodeAt(pos); + var len = text.length; + if (ch === 60 || ch === 62) { + while (pos < len && !isLineBreak(text.charCodeAt(pos))) { + pos++; + } + } + else { + ts.Debug.assert(ch === 124 || ch === 61); + while (pos < len) { + var currentChar = text.charCodeAt(pos); + if ((currentChar === 61 || currentChar === 62) && currentChar !== ch && isConflictMarkerTrivia(text, pos)) { + break; + } + pos++; + } + } + return pos; + } + var shebangTriviaRegex = /^#!.*/; + function isShebangTrivia(text, pos) { + ts.Debug.assert(pos === 0); + return shebangTriviaRegex.test(text); + } + ts.isShebangTrivia = isShebangTrivia; + function scanShebangTrivia(text, pos) { + var shebang = shebangTriviaRegex.exec(text)[0]; + pos = pos + shebang.length; + return pos; + } + ts.scanShebangTrivia = scanShebangTrivia; + function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) { + var pendingPos; + var pendingEnd; + var pendingKind; + var pendingHasTrailingNewLine; + var hasPendingCommentRange = false; + var collecting = trailing; + var accumulator = initial; + if (pos === 0) { + collecting = true; + var shebang = getShebang(text); + if (shebang) { + pos = shebang.length; + } + } + scan: while (pos >= 0 && pos < text.length) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + if (text.charCodeAt(pos + 1) === 10) { + pos++; + } + case 10: + pos++; + if (trailing) { + break scan; + } + collecting = true; + if (hasPendingCommentRange) { + pendingHasTrailingNewLine = true; + } + continue; + case 9: + case 11: + case 12: + case 32: + pos++; + continue; + case 47: + var nextChar = text.charCodeAt(pos + 1); + var hasTrailingNewLine = false; + if (nextChar === 47 || nextChar === 42) { + var kind = nextChar === 47 ? 2 : 3; + var startPos = pos; + pos += 2; + if (nextChar === 47) { + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + hasTrailingNewLine = true; + break; + } + pos++; + } + } + else { + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + break; + } + pos++; + } + } + if (collecting) { + if (hasPendingCommentRange) { + accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); + if (!reduce && accumulator) { + return accumulator; + } + } + pendingPos = startPos; + pendingEnd = pos; + pendingKind = kind; + pendingHasTrailingNewLine = hasTrailingNewLine; + hasPendingCommentRange = true; + } + continue; + } + break scan; + default: + if (ch > 127 && (isWhiteSpaceLike(ch))) { + if (hasPendingCommentRange && isLineBreak(ch)) { + pendingHasTrailingNewLine = true; + } + pos++; + continue; + } + break scan; + } + } + if (hasPendingCommentRange) { + accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); + } + return accumulator; + } + function forEachLeadingCommentRange(text, pos, cb, state) { + return iterateCommentRanges(false, text, pos, false, cb, state); + } + ts.forEachLeadingCommentRange = forEachLeadingCommentRange; + function forEachTrailingCommentRange(text, pos, cb, state) { + return iterateCommentRanges(false, text, pos, true, cb, state); + } + ts.forEachTrailingCommentRange = forEachTrailingCommentRange; + function reduceEachLeadingCommentRange(text, pos, cb, state, initial) { + return iterateCommentRanges(true, text, pos, false, cb, state, initial); + } + ts.reduceEachLeadingCommentRange = reduceEachLeadingCommentRange; + function reduceEachTrailingCommentRange(text, pos, cb, state, initial) { + return iterateCommentRanges(true, text, pos, true, cb, state, initial); + } + ts.reduceEachTrailingCommentRange = reduceEachTrailingCommentRange; + function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) { + if (!comments) { + comments = []; + } + comments.push({ kind: kind, pos: pos, end: end, hasTrailingNewLine: hasTrailingNewLine }); + return comments; + } + function getLeadingCommentRanges(text, pos) { + return reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined); + } + ts.getLeadingCommentRanges = getLeadingCommentRanges; + function getTrailingCommentRanges(text, pos) { + return reduceEachTrailingCommentRange(text, pos, appendCommentRange, undefined, undefined); + } + ts.getTrailingCommentRanges = getTrailingCommentRanges; + function getShebang(text) { + var match = shebangTriviaRegex.exec(text); + if (match) { + return match[0]; + } + } + ts.getShebang = getShebang; + function isIdentifierStart(ch, languageVersion) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); + } + ts.isIdentifierStart = isIdentifierStart; + function isIdentifierPart(ch, languageVersion) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); + } + ts.isIdentifierPart = isIdentifierPart; + function isIdentifierText(name, languageVersion) { + var ch = codePointAt(name, 0); + if (!isIdentifierStart(ch, languageVersion)) { + return false; + } + for (var i = charSize(ch); i < name.length; i += charSize(ch)) { + if (!isIdentifierPart(ch = codePointAt(name, i), languageVersion)) { + return false; + } + } + return true; + } + ts.isIdentifierText = isIdentifierText; + function createScanner(languageVersion, skipTrivia, languageVariant, textInitial, onError, start, length) { + if (languageVariant === void 0) { languageVariant = 0; } + var text = textInitial; + var pos; + var end; + var startPos; + var tokenPos; + var token; + var tokenValue; + var tokenFlags; + var inJSDocType = 0; + setText(text, start, length); + var scanner = { + getStartPos: function () { return startPos; }, + getTextPos: function () { return pos; }, + getToken: function () { return token; }, + getTokenPos: function () { return tokenPos; }, + getTokenText: function () { return text.substring(tokenPos, pos); }, + getTokenValue: function () { return tokenValue; }, + hasUnicodeEscape: function () { return (tokenFlags & 1024) !== 0; }, + hasExtendedUnicodeEscape: function () { return (tokenFlags & 8) !== 0; }, + hasPrecedingLineBreak: function () { return (tokenFlags & 1) !== 0; }, + isIdentifier: function () { return token === 75 || token > 112; }, + isReservedWord: function () { return token >= 77 && token <= 112; }, + isUnterminated: function () { return (tokenFlags & 4) !== 0; }, + getTokenFlags: function () { return tokenFlags; }, + reScanGreaterToken: reScanGreaterToken, + reScanSlashToken: reScanSlashToken, + reScanTemplateToken: reScanTemplateToken, + scanJsxIdentifier: scanJsxIdentifier, + scanJsxAttributeValue: scanJsxAttributeValue, + reScanJsxAttributeValue: reScanJsxAttributeValue, + reScanJsxToken: reScanJsxToken, + reScanLessThanToken: reScanLessThanToken, + reScanQuestionToken: reScanQuestionToken, + scanJsxToken: scanJsxToken, + scanJsDocToken: scanJsDocToken, + scan: scan, + getText: getText, + setText: setText, + setScriptTarget: setScriptTarget, + setLanguageVariant: setLanguageVariant, + setOnError: setOnError, + setTextPos: setTextPos, + setInJSDocType: setInJSDocType, + tryScan: tryScan, + lookAhead: lookAhead, + scanRange: scanRange, + }; + if (ts.Debug.isDebugging) { + Object.defineProperty(scanner, "__debugShowCurrentPositionInText", { + get: function () { + var text = scanner.getText(); + return text.slice(0, scanner.getStartPos()) + "â•‘" + text.slice(scanner.getStartPos()); + }, + }); + } + return scanner; + function error(message, errPos, length) { + if (errPos === void 0) { errPos = pos; } + if (onError) { + var oldPos = pos; + pos = errPos; + onError(message, length || 0); + pos = oldPos; + } + } + function scanNumberFragment() { + var start = pos; + var allowSeparator = false; + var isPreviousTokenSeparator = false; + var result = ""; + while (true) { + var ch = text.charCodeAt(pos); + if (ch === 95) { + tokenFlags |= 512; + if (allowSeparator) { + allowSeparator = false; + isPreviousTokenSeparator = true; + result += text.substring(start, pos); + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + start = pos; + continue; + } + if (isDigit(ch)) { + allowSeparator = true; + isPreviousTokenSeparator = false; + pos++; + continue; + } + break; + } + if (text.charCodeAt(pos - 1) === 95) { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return result + text.substring(start, pos); + } + function scanNumber() { + var start = pos; + var mainFragment = scanNumberFragment(); + var decimalFragment; + var scientificFragment; + if (text.charCodeAt(pos) === 46) { + pos++; + decimalFragment = scanNumberFragment(); + } + var end = pos; + if (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101) { + pos++; + tokenFlags |= 16; + if (text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) + pos++; + var preNumericPart = pos; + var finalFragment = scanNumberFragment(); + if (!finalFragment) { + error(ts.Diagnostics.Digit_expected); + } + else { + scientificFragment = text.substring(end, preNumericPart) + finalFragment; + end = pos; + } + } + var result; + if (tokenFlags & 512) { + result = mainFragment; + if (decimalFragment) { + result += "." + decimalFragment; + } + if (scientificFragment) { + result += scientificFragment; + } + } + else { + result = text.substring(start, end); + } + if (decimalFragment !== undefined || tokenFlags & 16) { + checkForIdentifierStartAfterNumericLiteral(start, decimalFragment === undefined && !!(tokenFlags & 16)); + return { + type: 8, + value: "" + +result + }; + } + else { + tokenValue = result; + var type = checkBigIntSuffix(); + checkForIdentifierStartAfterNumericLiteral(start); + return { type: type, value: tokenValue }; + } + } + function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) { + if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) { + return; + } + var identifierStart = pos; + var length = scanIdentifierParts().length; + if (length === 1 && text[identifierStart] === "n") { + if (isScientific) { + error(ts.Diagnostics.A_bigint_literal_cannot_use_exponential_notation, numericStart, identifierStart - numericStart + 1); + } + else { + error(ts.Diagnostics.A_bigint_literal_must_be_an_integer, numericStart, identifierStart - numericStart + 1); + } + } + else { + error(ts.Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, identifierStart, length); + pos = identifierStart; + } + } + function scanOctalDigits() { + var start = pos; + while (isOctalDigit(text.charCodeAt(pos))) { + pos++; + } + return +(text.substring(start, pos)); + } + function scanExactNumberOfHexDigits(count, canHaveSeparators) { + var valueString = scanHexDigits(count, false, canHaveSeparators); + return valueString ? parseInt(valueString, 16) : -1; + } + function scanMinimumNumberOfHexDigits(count, canHaveSeparators) { + return scanHexDigits(count, true, canHaveSeparators); + } + function scanHexDigits(minCount, scanAsManyAsPossible, canHaveSeparators) { + var valueChars = []; + var allowSeparator = false; + var isPreviousTokenSeparator = false; + while (valueChars.length < minCount || scanAsManyAsPossible) { + var ch = text.charCodeAt(pos); + if (canHaveSeparators && ch === 95) { + tokenFlags |= 512; + if (allowSeparator) { + allowSeparator = false; + isPreviousTokenSeparator = true; + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + continue; + } + allowSeparator = canHaveSeparators; + if (ch >= 65 && ch <= 70) { + ch += 97 - 65; + } + else if (!((ch >= 48 && ch <= 57) || + (ch >= 97 && ch <= 102))) { + break; + } + valueChars.push(ch); + pos++; + isPreviousTokenSeparator = false; + } + if (valueChars.length < minCount) { + valueChars = []; + } + if (text.charCodeAt(pos - 1) === 95) { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return String.fromCharCode.apply(String, valueChars); + } + function scanString(jsxAttributeString) { + if (jsxAttributeString === void 0) { jsxAttributeString = false; } + var quote = text.charCodeAt(pos); + pos++; + var result = ""; + var start = pos; + while (true) { + if (pos >= end) { + result += text.substring(start, pos); + tokenFlags |= 4; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + var ch = text.charCodeAt(pos); + if (ch === quote) { + result += text.substring(start, pos); + pos++; + break; + } + if (ch === 92 && !jsxAttributeString) { + result += text.substring(start, pos); + result += scanEscapeSequence(); + start = pos; + continue; + } + if (isLineBreak(ch) && !jsxAttributeString) { + result += text.substring(start, pos); + tokenFlags |= 4; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + pos++; + } + return result; + } + function scanTemplateAndSetTokenValue() { + var startedWithBacktick = text.charCodeAt(pos) === 96; + pos++; + var start = pos; + var contents = ""; + var resultingToken; + while (true) { + if (pos >= end) { + contents += text.substring(start, pos); + tokenFlags |= 4; + error(ts.Diagnostics.Unterminated_template_literal); + resultingToken = startedWithBacktick ? 14 : 17; + break; + } + var currChar = text.charCodeAt(pos); + if (currChar === 96) { + contents += text.substring(start, pos); + pos++; + resultingToken = startedWithBacktick ? 14 : 17; + break; + } + if (currChar === 36 && pos + 1 < end && text.charCodeAt(pos + 1) === 123) { + contents += text.substring(start, pos); + pos += 2; + resultingToken = startedWithBacktick ? 15 : 16; + break; + } + if (currChar === 92) { + contents += text.substring(start, pos); + contents += scanEscapeSequence(); + start = pos; + continue; + } + if (currChar === 13) { + contents += text.substring(start, pos); + pos++; + if (pos < end && text.charCodeAt(pos) === 10) { + pos++; + } + contents += "\n"; + start = pos; + continue; + } + pos++; + } + ts.Debug.assert(resultingToken !== undefined); + tokenValue = contents; + return resultingToken; + } + function scanEscapeSequence() { + pos++; + if (pos >= end) { + error(ts.Diagnostics.Unexpected_end_of_text); + return ""; + } + var ch = text.charCodeAt(pos); + pos++; + switch (ch) { + case 48: + return "\0"; + case 98: + return "\b"; + case 116: + return "\t"; + case 110: + return "\n"; + case 118: + return "\v"; + case 102: + return "\f"; + case 114: + return "\r"; + case 39: + return "\'"; + case 34: + return "\""; + case 117: + if (pos < end && text.charCodeAt(pos) === 123) { + tokenFlags |= 8; + pos++; + return scanExtendedUnicodeEscape(); + } + tokenFlags |= 1024; + return scanHexadecimalEscape(4); + case 120: + return scanHexadecimalEscape(2); + case 13: + if (pos < end && text.charCodeAt(pos) === 10) { + pos++; + } + case 10: + case 8232: + case 8233: + return ""; + default: + return String.fromCharCode(ch); + } + } + function scanHexadecimalEscape(numDigits) { + var escapedValue = scanExactNumberOfHexDigits(numDigits, false); + if (escapedValue >= 0) { + return String.fromCharCode(escapedValue); + } + else { + error(ts.Diagnostics.Hexadecimal_digit_expected); + return ""; + } + } + function scanExtendedUnicodeEscape() { + var escapedValueString = scanMinimumNumberOfHexDigits(1, false); + var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; + var isInvalidExtendedEscape = false; + if (escapedValue < 0) { + error(ts.Diagnostics.Hexadecimal_digit_expected); + isInvalidExtendedEscape = true; + } + else if (escapedValue > 0x10FFFF) { + error(ts.Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive); + isInvalidExtendedEscape = true; + } + if (pos >= end) { + error(ts.Diagnostics.Unexpected_end_of_text); + isInvalidExtendedEscape = true; + } + else if (text.charCodeAt(pos) === 125) { + pos++; + } + else { + error(ts.Diagnostics.Unterminated_Unicode_escape_sequence); + isInvalidExtendedEscape = true; + } + if (isInvalidExtendedEscape) { + return ""; + } + return utf16EncodeAsString(escapedValue); + } + function peekUnicodeEscape() { + if (pos + 5 < end && text.charCodeAt(pos + 1) === 117) { + var start_1 = pos; + pos += 2; + var value = scanExactNumberOfHexDigits(4, false); + pos = start_1; + return value; + } + return -1; + } + function peekExtendedUnicodeEscape() { + if (languageVersion >= 2 && codePointAt(text, pos + 1) === 117 && codePointAt(text, pos + 2) === 123) { + var start_2 = pos; + pos += 3; + var escapedValueString = scanMinimumNumberOfHexDigits(1, false); + var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; + pos = start_2; + return escapedValue; + } + return -1; + } + function scanIdentifierParts() { + var result = ""; + var start = pos; + while (pos < end) { + var ch = codePointAt(text, pos); + if (isIdentifierPart(ch, languageVersion)) { + pos += charSize(ch); + } + else if (ch === 92) { + ch = peekExtendedUnicodeEscape(); + if (ch >= 0 && isIdentifierPart(ch, languageVersion)) { + pos += 3; + tokenFlags |= 8; + result += scanExtendedUnicodeEscape(); + start = pos; + continue; + } + ch = peekUnicodeEscape(); + if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) { + break; + } + tokenFlags |= 1024; + result += text.substring(start, pos); + result += utf16EncodeAsString(ch); + pos += 6; + start = pos; + } + else { + break; + } + } + result += text.substring(start, pos); + return result; + } + function getIdentifierToken() { + var len = tokenValue.length; + if (len >= 2 && len <= 11) { + var ch = tokenValue.charCodeAt(0); + if (ch >= 97 && ch <= 122) { + var keyword = textToKeyword.get(tokenValue); + if (keyword !== undefined) { + return token = keyword; + } + } + } + return token = 75; + } + function scanBinaryOrOctalDigits(base) { + var value = ""; + var separatorAllowed = false; + var isPreviousTokenSeparator = false; + while (true) { + var ch = text.charCodeAt(pos); + if (ch === 95) { + tokenFlags |= 512; + if (separatorAllowed) { + separatorAllowed = false; + isPreviousTokenSeparator = true; + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + continue; + } + separatorAllowed = true; + if (!isDigit(ch) || ch - 48 >= base) { + break; + } + value += text[pos]; + pos++; + isPreviousTokenSeparator = false; + } + if (text.charCodeAt(pos - 1) === 95) { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return value; + } + function checkBigIntSuffix() { + if (text.charCodeAt(pos) === 110) { + tokenValue += "n"; + if (tokenFlags & 384) { + tokenValue = ts.parsePseudoBigInt(tokenValue) + "n"; + } + pos++; + return 9; + } + else { + var numericValue = tokenFlags & 128 + ? parseInt(tokenValue.slice(2), 2) + : tokenFlags & 256 + ? parseInt(tokenValue.slice(2), 8) + : +tokenValue; + tokenValue = "" + numericValue; + return 8; + } + } + function scan() { + var _a; + startPos = pos; + tokenFlags = 0; + var asteriskSeen = false; + while (true) { + tokenPos = pos; + if (pos >= end) { + return token = 1; + } + var ch = codePointAt(text, pos); + if (ch === 35 && pos === 0 && isShebangTrivia(text, pos)) { + pos = scanShebangTrivia(text, pos); + if (skipTrivia) { + continue; + } + else { + return token = 6; + } + } + switch (ch) { + case 10: + case 13: + tokenFlags |= 1; + if (skipTrivia) { + pos++; + continue; + } + else { + if (ch === 13 && pos + 1 < end && text.charCodeAt(pos + 1) === 10) { + pos += 2; + } + else { + pos++; + } + return token = 4; + } + case 9: + case 11: + case 12: + case 32: + case 160: + case 5760: + case 8192: + case 8193: + case 8194: + case 8195: + case 8196: + case 8197: + case 8198: + case 8199: + case 8200: + case 8201: + case 8202: + case 8203: + case 8239: + case 8287: + case 12288: + case 65279: + if (skipTrivia) { + pos++; + continue; + } + else { + while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { + pos++; + } + return token = 5; + } + case 33: + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 37; + } + return pos += 2, token = 35; + } + pos++; + return token = 53; + case 34: + case 39: + tokenValue = scanString(); + return token = 10; + case 96: + return token = scanTemplateAndSetTokenValue(); + case 37: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 68; + } + pos++; + return token = 44; + case 38: + if (text.charCodeAt(pos + 1) === 38) { + return pos += 2, token = 55; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 72; + } + pos++; + return token = 50; + case 40: + pos++; + return token = 20; + case 41: + pos++; + return token = 21; + case 42: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 65; + } + if (text.charCodeAt(pos + 1) === 42) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 66; + } + return pos += 2, token = 42; + } + pos++; + if (inJSDocType && !asteriskSeen && (tokenFlags & 1)) { + asteriskSeen = true; + continue; + } + return token = 41; + case 43: + if (text.charCodeAt(pos + 1) === 43) { + return pos += 2, token = 45; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 63; + } + pos++; + return token = 39; + case 44: + pos++; + return token = 27; + case 45: + if (text.charCodeAt(pos + 1) === 45) { + return pos += 2, token = 46; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 64; + } + pos++; + return token = 40; + case 46: + if (isDigit(text.charCodeAt(pos + 1))) { + tokenValue = scanNumber().value; + return token = 8; + } + if (text.charCodeAt(pos + 1) === 46 && text.charCodeAt(pos + 2) === 46) { + return pos += 3, token = 25; + } + pos++; + return token = 24; + case 47: + if (text.charCodeAt(pos + 1) === 47) { + pos += 2; + while (pos < end) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + if (skipTrivia) { + continue; + } + else { + return token = 2; + } + } + if (text.charCodeAt(pos + 1) === 42) { + pos += 2; + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) !== 47) { + tokenFlags |= 2; + } + var commentClosed = false; + while (pos < end) { + var ch_1 = text.charCodeAt(pos); + if (ch_1 === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + commentClosed = true; + break; + } + if (isLineBreak(ch_1)) { + tokenFlags |= 1; + } + pos++; + } + if (!commentClosed) { + error(ts.Diagnostics.Asterisk_Slash_expected); + } + if (skipTrivia) { + continue; + } + else { + if (!commentClosed) { + tokenFlags |= 4; + } + return token = 3; + } + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 67; + } + pos++; + return token = 43; + case 48: + if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 || text.charCodeAt(pos + 1) === 120)) { + pos += 2; + tokenValue = scanMinimumNumberOfHexDigits(1, true); + if (!tokenValue) { + error(ts.Diagnostics.Hexadecimal_digit_expected); + tokenValue = "0"; + } + tokenValue = "0x" + tokenValue; + tokenFlags |= 64; + return token = checkBigIntSuffix(); + } + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 || text.charCodeAt(pos + 1) === 98)) { + pos += 2; + tokenValue = scanBinaryOrOctalDigits(2); + if (!tokenValue) { + error(ts.Diagnostics.Binary_digit_expected); + tokenValue = "0"; + } + tokenValue = "0b" + tokenValue; + tokenFlags |= 128; + return token = checkBigIntSuffix(); + } + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 || text.charCodeAt(pos + 1) === 111)) { + pos += 2; + tokenValue = scanBinaryOrOctalDigits(8); + if (!tokenValue) { + error(ts.Diagnostics.Octal_digit_expected); + tokenValue = "0"; + } + tokenValue = "0o" + tokenValue; + tokenFlags |= 256; + return token = checkBigIntSuffix(); + } + if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) { + tokenValue = "" + scanOctalDigits(); + tokenFlags |= 32; + return token = 8; + } + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + (_a = scanNumber(), token = _a.type, tokenValue = _a.value); + return token; + case 58: + pos++; + return token = 58; + case 59: + pos++; + return token = 26; + case 60: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7; + } + } + if (text.charCodeAt(pos + 1) === 60) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 69; + } + return pos += 2, token = 47; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 32; + } + if (languageVariant === 1 && + text.charCodeAt(pos + 1) === 47 && + text.charCodeAt(pos + 2) !== 42) { + return pos += 2, token = 30; + } + pos++; + return token = 29; + case 61: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7; + } + } + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 36; + } + return pos += 2, token = 34; + } + if (text.charCodeAt(pos + 1) === 62) { + return pos += 2, token = 38; + } + pos++; + return token = 62; + case 62: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7; + } + } + pos++; + return token = 31; + case 63: + pos++; + if (text.charCodeAt(pos) === 46 && !isDigit(text.charCodeAt(pos + 1))) { + pos++; + return token = 28; + } + if (text.charCodeAt(pos) === 63) { + pos++; + return token = 60; + } + return token = 57; + case 91: + pos++; + return token = 22; + case 93: + pos++; + return token = 23; + case 94: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 74; + } + pos++; + return token = 52; + case 123: + pos++; + return token = 18; + case 124: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7; + } + } + if (text.charCodeAt(pos + 1) === 124) { + return pos += 2, token = 56; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 73; + } + pos++; + return token = 51; + case 125: + pos++; + return token = 19; + case 126: + pos++; + return token = 54; + case 64: + pos++; + return token = 59; + case 92: + var extendedCookedChar = peekExtendedUnicodeEscape(); + if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { + pos += 3; + tokenFlags |= 8; + tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); + return token = getIdentifierToken(); + } + var cookedChar = peekUnicodeEscape(); + if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { + pos += 6; + tokenFlags |= 1024; + tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); + return token = getIdentifierToken(); + } + error(ts.Diagnostics.Invalid_character); + pos++; + return token = 0; + case 35: + if (pos !== 0 && text[pos + 1] === "!") { + error(ts.Diagnostics.can_only_be_used_at_the_start_of_a_file); + pos++; + return token = 0; + } + pos++; + if (isIdentifierStart(ch = text.charCodeAt(pos), languageVersion)) { + pos++; + while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion)) + pos++; + tokenValue = text.substring(tokenPos, pos); + if (ch === 92) { + tokenValue += scanIdentifierParts(); + } + } + else { + tokenValue = "#"; + error(ts.Diagnostics.Invalid_character); + } + return token = 76; + default: + if (isIdentifierStart(ch, languageVersion)) { + pos += charSize(ch); + while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion)) + pos += charSize(ch); + tokenValue = text.substring(tokenPos, pos); + if (ch === 92) { + tokenValue += scanIdentifierParts(); + } + return token = getIdentifierToken(); + } + else if (isWhiteSpaceSingleLine(ch)) { + pos += charSize(ch); + continue; + } + else if (isLineBreak(ch)) { + tokenFlags |= 1; + pos += charSize(ch); + continue; + } + error(ts.Diagnostics.Invalid_character); + pos += charSize(ch); + return token = 0; + } + } + } + function reScanGreaterToken() { + if (token === 31) { + if (text.charCodeAt(pos) === 62) { + if (text.charCodeAt(pos + 1) === 62) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 71; + } + return pos += 2, token = 49; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 70; + } + pos++; + return token = 48; + } + if (text.charCodeAt(pos) === 61) { + pos++; + return token = 33; + } + } + return token; + } + function reScanSlashToken() { + if (token === 43 || token === 67) { + var p = tokenPos + 1; + var inEscape = false; + var inCharacterClass = false; + while (true) { + if (p >= end) { + tokenFlags |= 4; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + var ch = text.charCodeAt(p); + if (isLineBreak(ch)) { + tokenFlags |= 4; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + if (inEscape) { + inEscape = false; + } + else if (ch === 47 && !inCharacterClass) { + p++; + break; + } + else if (ch === 91) { + inCharacterClass = true; + } + else if (ch === 92) { + inEscape = true; + } + else if (ch === 93) { + inCharacterClass = false; + } + p++; + } + while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) { + p++; + } + pos = p; + tokenValue = text.substring(tokenPos, pos); + token = 13; + } + return token; + } + function reScanTemplateToken() { + ts.Debug.assert(token === 19, "'reScanTemplateToken' should only be called on a '}'"); + pos = tokenPos; + return token = scanTemplateAndSetTokenValue(); + } + function reScanJsxToken() { + pos = tokenPos = startPos; + return token = scanJsxToken(); + } + function reScanLessThanToken() { + if (token === 47) { + pos = tokenPos + 1; + return token = 29; + } + return token; + } + function reScanQuestionToken() { + ts.Debug.assert(token === 60, "'reScanQuestionToken' should only be called on a '??'"); + pos = tokenPos + 1; + return token = 57; + } + function scanJsxToken() { + startPos = tokenPos = pos; + if (pos >= end) { + return token = 1; + } + var char = text.charCodeAt(pos); + if (char === 60) { + if (text.charCodeAt(pos + 1) === 47) { + pos += 2; + return token = 30; + } + pos++; + return token = 29; + } + if (char === 123) { + pos++; + return token = 18; + } + var firstNonWhitespace = 0; + var lastNonWhitespace = -1; + while (pos < end) { + if (!isWhiteSpaceSingleLine(char)) { + lastNonWhitespace = pos; + } + char = text.charCodeAt(pos); + if (char === 123) { + break; + } + if (char === 60) { + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + return token = 7; + } + break; + } + if (lastNonWhitespace > 0) + lastNonWhitespace++; + if (isLineBreak(char) && firstNonWhitespace === 0) { + firstNonWhitespace = -1; + } + else if (!isWhiteSpaceLike(char)) { + firstNonWhitespace = pos; + } + pos++; + } + var endPosition = lastNonWhitespace === -1 ? pos : lastNonWhitespace; + tokenValue = text.substring(startPos, endPosition); + return firstNonWhitespace === -1 ? 12 : 11; + } + function scanJsxIdentifier() { + if (tokenIsIdentifierOrKeyword(token)) { + while (pos < end) { + var ch = text.charCodeAt(pos); + if (ch === 45) { + tokenValue += "-"; + pos++; + continue; + } + var oldPos = pos; + tokenValue += scanIdentifierParts(); + if (pos === oldPos) { + break; + } + } + } + return token; + } + function scanJsxAttributeValue() { + startPos = pos; + switch (text.charCodeAt(pos)) { + case 34: + case 39: + tokenValue = scanString(true); + return token = 10; + default: + return scan(); + } + } + function reScanJsxAttributeValue() { + pos = tokenPos = startPos; + return scanJsxAttributeValue(); + } + function scanJsDocToken() { + startPos = tokenPos = pos; + tokenFlags = 0; + if (pos >= end) { + return token = 1; + } + var ch = codePointAt(text, pos); + pos += charSize(ch); + switch (ch) { + case 9: + case 11: + case 12: + case 32: + while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { + pos++; + } + return token = 5; + case 64: + return token = 59; + case 10: + case 13: + tokenFlags |= 1; + return token = 4; + case 42: + return token = 41; + case 123: + return token = 18; + case 125: + return token = 19; + case 91: + return token = 22; + case 93: + return token = 23; + case 60: + return token = 29; + case 62: + return token = 31; + case 61: + return token = 62; + case 44: + return token = 27; + case 46: + return token = 24; + case 96: + return token = 61; + case 92: + pos--; + var extendedCookedChar = peekExtendedUnicodeEscape(); + if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { + pos += 3; + tokenFlags |= 8; + tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); + return token = getIdentifierToken(); + } + var cookedChar = peekUnicodeEscape(); + if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { + pos += 6; + tokenFlags |= 1024; + tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); + return token = getIdentifierToken(); + } + pos++; + return token = 0; + } + if (isIdentifierStart(ch, languageVersion)) { + var char = ch; + while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45) + pos += charSize(char); + tokenValue = text.substring(tokenPos, pos); + if (char === 92) { + tokenValue += scanIdentifierParts(); + } + return token = getIdentifierToken(); + } + else { + return token = 0; + } + } + function speculationHelper(callback, isLookahead) { + var savePos = pos; + var saveStartPos = startPos; + var saveTokenPos = tokenPos; + var saveToken = token; + var saveTokenValue = tokenValue; + var saveTokenFlags = tokenFlags; + var result = callback(); + if (!result || isLookahead) { + pos = savePos; + startPos = saveStartPos; + tokenPos = saveTokenPos; + token = saveToken; + tokenValue = saveTokenValue; + tokenFlags = saveTokenFlags; + } + return result; + } + function scanRange(start, length, callback) { + var saveEnd = end; + var savePos = pos; + var saveStartPos = startPos; + var saveTokenPos = tokenPos; + var saveToken = token; + var saveTokenValue = tokenValue; + var saveTokenFlags = tokenFlags; + setText(text, start, length); + var result = callback(); + end = saveEnd; + pos = savePos; + startPos = saveStartPos; + tokenPos = saveTokenPos; + token = saveToken; + tokenValue = saveTokenValue; + tokenFlags = saveTokenFlags; + return result; + } + function lookAhead(callback) { + return speculationHelper(callback, true); + } + function tryScan(callback) { + return speculationHelper(callback, false); + } + function getText() { + return text; + } + function setText(newText, start, length) { + text = newText || ""; + end = length === undefined ? text.length : start + length; + setTextPos(start || 0); + } + function setOnError(errorCallback) { + onError = errorCallback; + } + function setScriptTarget(scriptTarget) { + languageVersion = scriptTarget; + } + function setLanguageVariant(variant) { + languageVariant = variant; + } + function setTextPos(textPos) { + ts.Debug.assert(textPos >= 0); + pos = textPos; + startPos = textPos; + tokenPos = textPos; + token = 0; + tokenValue = undefined; + tokenFlags = 0; + } + function setInJSDocType(inType) { + inJSDocType += inType ? 1 : -1; + } + } + ts.createScanner = createScanner; + var codePointAt = String.prototype.codePointAt ? function (s, i) { return s.codePointAt(i); } : function codePointAt(str, i) { + var size = str.length; + if (i < 0 || i >= size) { + return undefined; + } + var first = str.charCodeAt(i); + if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) { + var second = str.charCodeAt(i + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; + }; + function charSize(ch) { + if (ch >= 0x10000) { + return 2; + } + return 1; + } + function utf16EncodeAsStringFallback(codePoint) { + ts.Debug.assert(0x0 <= codePoint && codePoint <= 0x10FFFF); + if (codePoint <= 65535) { + return String.fromCharCode(codePoint); + } + var codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800; + var codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00; + return String.fromCharCode(codeUnit1, codeUnit2); + } + var utf16EncodeAsStringWorker = String.fromCodePoint ? function (codePoint) { return String.fromCodePoint(codePoint); } : utf16EncodeAsStringFallback; + function utf16EncodeAsString(codePoint) { + return utf16EncodeAsStringWorker(codePoint); + } + ts.utf16EncodeAsString = utf16EncodeAsString; +})(ts || (ts = {})); +var ts; +(function (ts) { + function isExternalModuleNameRelative(moduleName) { + return ts.pathIsRelative(moduleName) || ts.isRootedDiskPath(moduleName); + } + ts.isExternalModuleNameRelative = isExternalModuleNameRelative; + function sortAndDeduplicateDiagnostics(diagnostics) { + return ts.sortAndDeduplicate(diagnostics, ts.compareDiagnostics); + } + ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics; + function getDefaultLibFileName(options) { + switch (options.target) { + case 99: + return "lib.esnext.full.d.ts"; + case 7: + return "lib.es2020.full.d.ts"; + case 6: + return "lib.es2019.full.d.ts"; + case 5: + return "lib.es2018.full.d.ts"; + case 4: + return "lib.es2017.full.d.ts"; + case 3: + return "lib.es2016.full.d.ts"; + case 2: + return "lib.es6.d.ts"; + default: + return "lib.d.ts"; + } + } + ts.getDefaultLibFileName = getDefaultLibFileName; + function textSpanEnd(span) { + return span.start + span.length; + } + ts.textSpanEnd = textSpanEnd; + function textSpanIsEmpty(span) { + return span.length === 0; + } + ts.textSpanIsEmpty = textSpanIsEmpty; + function textSpanContainsPosition(span, position) { + return position >= span.start && position < textSpanEnd(span); + } + ts.textSpanContainsPosition = textSpanContainsPosition; + function textRangeContainsPositionInclusive(span, position) { + return position >= span.pos && position <= span.end; + } + ts.textRangeContainsPositionInclusive = textRangeContainsPositionInclusive; + function textSpanContainsTextSpan(span, other) { + return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span); + } + ts.textSpanContainsTextSpan = textSpanContainsTextSpan; + function textSpanOverlapsWith(span, other) { + return textSpanOverlap(span, other) !== undefined; + } + ts.textSpanOverlapsWith = textSpanOverlapsWith; + function textSpanOverlap(span1, span2) { + var overlap = textSpanIntersection(span1, span2); + return overlap && overlap.length === 0 ? undefined : overlap; + } + ts.textSpanOverlap = textSpanOverlap; + function textSpanIntersectsWithTextSpan(span, other) { + return decodedTextSpanIntersectsWith(span.start, span.length, other.start, other.length); + } + ts.textSpanIntersectsWithTextSpan = textSpanIntersectsWithTextSpan; + function textSpanIntersectsWith(span, start, length) { + return decodedTextSpanIntersectsWith(span.start, span.length, start, length); + } + ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; + function textSpanIntersectsWithPosition(span, position) { + return position <= textSpanEnd(span) && position >= span.start; + } + ts.textSpanIntersectsWithPosition = textSpanIntersectsWithPosition; + function textSpanIntersection(span1, span2) { + var start = Math.max(span1.start, span2.start); + var end = Math.min(textSpanEnd(span1), textSpanEnd(span2)); + return start <= end ? createTextSpanFromBounds(start, end) : undefined; + } + ts.textSpanIntersection = textSpanIntersection; + function createTextSpan(start, length) { + if (start < 0) { + throw new Error("start < 0"); + } + if (length < 0) { + throw new Error("length < 0"); + } + return { start: start, length: length }; + } + ts.createTextSpan = createTextSpan; + function createTextSpanFromBounds(start, end) { + return createTextSpan(start, end - start); + } + ts.createTextSpanFromBounds = createTextSpanFromBounds; + function textChangeRangeNewSpan(range) { + return createTextSpan(range.span.start, range.newLength); + } + ts.textChangeRangeNewSpan = textChangeRangeNewSpan; + function textChangeRangeIsUnchanged(range) { + return textSpanIsEmpty(range.span) && range.newLength === 0; + } + ts.textChangeRangeIsUnchanged = textChangeRangeIsUnchanged; + function createTextChangeRange(span, newLength) { + if (newLength < 0) { + throw new Error("newLength < 0"); + } + return { span: span, newLength: newLength }; + } + ts.createTextChangeRange = createTextChangeRange; + ts.unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); + function collapseTextChangeRangesAcrossMultipleVersions(changes) { + if (changes.length === 0) { + return ts.unchangedTextChangeRange; + } + if (changes.length === 1) { + return changes[0]; + } + var change0 = changes[0]; + var oldStartN = change0.span.start; + var oldEndN = textSpanEnd(change0.span); + var newEndN = oldStartN + change0.newLength; + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + var oldStart2 = nextChange.span.start; + var oldEnd2 = textSpanEnd(nextChange.span); + var newEnd2 = oldStart2 + nextChange.newLength; + oldStartN = Math.min(oldStart1, oldStart2); + oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), newEndN - oldStartN); + } + ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; + function getTypeParameterOwner(d) { + if (d && d.kind === 155) { + for (var current = d; current; current = current.parent) { + if (isFunctionLike(current) || isClassLike(current) || current.kind === 246) { + return current; + } + } + } + } + ts.getTypeParameterOwner = getTypeParameterOwner; + function isParameterPropertyDeclaration(node, parent) { + return ts.hasModifier(node, 92) && parent.kind === 162; + } + ts.isParameterPropertyDeclaration = isParameterPropertyDeclaration; + function isEmptyBindingPattern(node) { + if (isBindingPattern(node)) { + return ts.every(node.elements, isEmptyBindingElement); + } + return false; + } + ts.isEmptyBindingPattern = isEmptyBindingPattern; + function isEmptyBindingElement(node) { + if (isOmittedExpression(node)) { + return true; + } + return isEmptyBindingPattern(node.name); + } + ts.isEmptyBindingElement = isEmptyBindingElement; + function walkUpBindingElementsAndPatterns(binding) { + var node = binding.parent; + while (isBindingElement(node.parent)) { + node = node.parent.parent; + } + return node.parent; + } + ts.walkUpBindingElementsAndPatterns = walkUpBindingElementsAndPatterns; + function getCombinedFlags(node, getFlags) { + if (isBindingElement(node)) { + node = walkUpBindingElementsAndPatterns(node); + } + var flags = getFlags(node); + if (node.kind === 242) { + node = node.parent; + } + if (node && node.kind === 243) { + flags |= getFlags(node); + node = node.parent; + } + if (node && node.kind === 225) { + flags |= getFlags(node); + } + return flags; + } + function getCombinedModifierFlags(node) { + return getCombinedFlags(node, ts.getModifierFlags); + } + ts.getCombinedModifierFlags = getCombinedModifierFlags; + function getCombinedNodeFlags(node) { + return getCombinedFlags(node, function (n) { return n.flags; }); + } + ts.getCombinedNodeFlags = getCombinedNodeFlags; + function validateLocaleAndSetLanguage(locale, sys, errors) { + var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase()); + if (!matchResult) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp")); + } + return; + } + var language = matchResult[1]; + var territory = matchResult[3]; + if (!trySetLanguageAndTerritory(language, territory, errors)) { + trySetLanguageAndTerritory(language, undefined, errors); + } + ts.setUILocale(locale); + function trySetLanguageAndTerritory(language, territory, errors) { + var compilerFilePath = ts.normalizePath(sys.getExecutingFilePath()); + var containingDirectoryPath = ts.getDirectoryPath(compilerFilePath); + var filePath = ts.combinePaths(containingDirectoryPath, language); + if (territory) { + filePath = filePath + "-" + territory; + } + filePath = sys.resolvePath(ts.combinePaths(filePath, "diagnosticMessages.generated.json")); + if (!sys.fileExists(filePath)) { + return false; + } + var fileContents = ""; + try { + fileContents = sys.readFile(filePath); + } + catch (e) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unable_to_open_file_0, filePath)); + } + return false; + } + try { + ts.setLocalizedDiagnosticMessages(JSON.parse(fileContents)); + } + catch (_a) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Corrupted_locale_file_0, filePath)); + } + return false; + } + return true; + } + } + ts.validateLocaleAndSetLanguage = validateLocaleAndSetLanguage; + function getOriginalNode(node, nodeTest) { + if (node) { + while (node.original !== undefined) { + node = node.original; + } + } + return !nodeTest || nodeTest(node) ? node : undefined; + } + ts.getOriginalNode = getOriginalNode; + function isParseTreeNode(node) { + return (node.flags & 8) === 0; + } + ts.isParseTreeNode = isParseTreeNode; + function getParseTreeNode(node, nodeTest) { + if (node === undefined || isParseTreeNode(node)) { + return node; + } + node = getOriginalNode(node); + if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) { + return node; + } + return undefined; + } + ts.getParseTreeNode = getParseTreeNode; + function escapeLeadingUnderscores(identifier) { + return (identifier.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier); + } + ts.escapeLeadingUnderscores = escapeLeadingUnderscores; + function unescapeLeadingUnderscores(identifier) { + var id = identifier; + return id.length >= 3 && id.charCodeAt(0) === 95 && id.charCodeAt(1) === 95 && id.charCodeAt(2) === 95 ? id.substr(1) : id; + } + ts.unescapeLeadingUnderscores = unescapeLeadingUnderscores; + function idText(identifierOrPrivateName) { + return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText); + } + ts.idText = idText; + function symbolName(symbol) { + if (symbol.valueDeclaration && isPrivateIdentifierPropertyDeclaration(symbol.valueDeclaration)) { + return idText(symbol.valueDeclaration.name); + } + return unescapeLeadingUnderscores(symbol.escapedName); + } + ts.symbolName = symbolName; + function nameForNamelessJSDocTypedef(declaration) { + var hostNode = declaration.parent.parent; + if (!hostNode) { + return undefined; + } + if (isDeclaration(hostNode)) { + return getDeclarationIdentifier(hostNode); + } + switch (hostNode.kind) { + case 225: + if (hostNode.declarationList && hostNode.declarationList.declarations[0]) { + return getDeclarationIdentifier(hostNode.declarationList.declarations[0]); + } + break; + case 226: + var expr = hostNode.expression; + if (expr.kind === 209 && expr.operatorToken.kind === 62) { + expr = expr.left; + } + switch (expr.kind) { + case 194: + return expr.name; + case 195: + var arg = expr.argumentExpression; + if (isIdentifier(arg)) { + return arg; + } + } + break; + case 200: { + return getDeclarationIdentifier(hostNode.expression); + } + case 238: { + if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) { + return getDeclarationIdentifier(hostNode.statement); + } + break; + } + } + } + function getDeclarationIdentifier(node) { + var name = getNameOfDeclaration(node); + return name && isIdentifier(name) ? name : undefined; + } + function nodeHasName(statement, name) { + if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) { + return true; + } + if (isVariableStatement(statement) && ts.some(statement.declarationList.declarations, function (d) { return nodeHasName(d, name); })) { + return true; + } + return false; + } + ts.nodeHasName = nodeHasName; + function getNameOfJSDocTypedef(declaration) { + return declaration.name || nameForNamelessJSDocTypedef(declaration); + } + ts.getNameOfJSDocTypedef = getNameOfJSDocTypedef; + function isNamedDeclaration(node) { + return !!node.name; + } + ts.isNamedDeclaration = isNamedDeclaration; + function getNonAssignedNameOfDeclaration(declaration) { + switch (declaration.kind) { + case 75: + return declaration; + case 322: + case 316: { + var name = declaration.name; + if (name.kind === 153) { + return name.right; + } + break; + } + case 196: + case 209: { + var expr_1 = declaration; + switch (ts.getAssignmentDeclarationKind(expr_1)) { + case 1: + case 4: + case 5: + case 3: + return ts.getElementOrPropertyAccessArgumentExpressionOrName(expr_1.left); + case 7: + case 8: + case 9: + return expr_1.arguments[1]; + default: + return undefined; + } + } + case 321: + return getNameOfJSDocTypedef(declaration); + case 315: + return nameForNamelessJSDocTypedef(declaration); + case 259: { + var expression = declaration.expression; + return isIdentifier(expression) ? expression : undefined; + } + case 195: + var expr = declaration; + if (ts.isBindableStaticElementAccessExpression(expr)) { + return expr.argumentExpression; + } + } + return declaration.name; + } + ts.getNonAssignedNameOfDeclaration = getNonAssignedNameOfDeclaration; + function getNameOfDeclaration(declaration) { + if (declaration === undefined) + return undefined; + return getNonAssignedNameOfDeclaration(declaration) || + (isFunctionExpression(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : undefined); + } + ts.getNameOfDeclaration = getNameOfDeclaration; + function getAssignedName(node) { + if (!node.parent) { + return undefined; + } + else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) { + return node.parent.name; + } + else if (isBinaryExpression(node.parent) && node === node.parent.right) { + if (isIdentifier(node.parent.left)) { + return node.parent.left; + } + else if (ts.isAccessExpression(node.parent.left)) { + return ts.getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left); + } + } + else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) { + return node.parent.name; + } + } + function getJSDocParameterTags(param) { + if (param.name) { + if (isIdentifier(param.name)) { + var name_1 = param.name.escapedText; + return getJSDocTags(param.parent).filter(function (tag) { return isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name_1; }); + } + else { + var i = param.parent.parameters.indexOf(param); + ts.Debug.assert(i > -1, "Parameters should always be in their parents' parameter list"); + var paramTags = getJSDocTags(param.parent).filter(isJSDocParameterTag); + if (i < paramTags.length) { + return [paramTags[i]]; + } + } + } + return ts.emptyArray; + } + ts.getJSDocParameterTags = getJSDocParameterTags; + function getJSDocTypeParameterTags(param) { + var name = param.name.escapedText; + return getJSDocTags(param.parent).filter(function (tag) { + return isJSDocTemplateTag(tag) && tag.typeParameters.some(function (tp) { return tp.name.escapedText === name; }); + }); + } + ts.getJSDocTypeParameterTags = getJSDocTypeParameterTags; + function hasJSDocParameterTags(node) { + return !!getFirstJSDocTag(node, isJSDocParameterTag); + } + ts.hasJSDocParameterTags = hasJSDocParameterTags; + function getJSDocAugmentsTag(node) { + return getFirstJSDocTag(node, isJSDocAugmentsTag); + } + ts.getJSDocAugmentsTag = getJSDocAugmentsTag; + function getJSDocClassTag(node) { + return getFirstJSDocTag(node, isJSDocClassTag); + } + ts.getJSDocClassTag = getJSDocClassTag; + function getJSDocPublicTag(node) { + return getFirstJSDocTag(node, isJSDocPublicTag); + } + ts.getJSDocPublicTag = getJSDocPublicTag; + function getJSDocPrivateTag(node) { + return getFirstJSDocTag(node, isJSDocPrivateTag); + } + ts.getJSDocPrivateTag = getJSDocPrivateTag; + function getJSDocProtectedTag(node) { + return getFirstJSDocTag(node, isJSDocProtectedTag); + } + ts.getJSDocProtectedTag = getJSDocProtectedTag; + function getJSDocReadonlyTag(node) { + return getFirstJSDocTag(node, isJSDocReadonlyTag); + } + ts.getJSDocReadonlyTag = getJSDocReadonlyTag; + function getJSDocEnumTag(node) { + return getFirstJSDocTag(node, isJSDocEnumTag); + } + ts.getJSDocEnumTag = getJSDocEnumTag; + function getJSDocThisTag(node) { + return getFirstJSDocTag(node, isJSDocThisTag); + } + ts.getJSDocThisTag = getJSDocThisTag; + function getJSDocReturnTag(node) { + return getFirstJSDocTag(node, isJSDocReturnTag); + } + ts.getJSDocReturnTag = getJSDocReturnTag; + function getJSDocTemplateTag(node) { + return getFirstJSDocTag(node, isJSDocTemplateTag); + } + ts.getJSDocTemplateTag = getJSDocTemplateTag; + function getJSDocTypeTag(node) { + var tag = getFirstJSDocTag(node, isJSDocTypeTag); + if (tag && tag.typeExpression && tag.typeExpression.type) { + return tag; + } + return undefined; + } + ts.getJSDocTypeTag = getJSDocTypeTag; + function getJSDocType(node) { + var tag = getFirstJSDocTag(node, isJSDocTypeTag); + if (!tag && isParameter(node)) { + tag = ts.find(getJSDocParameterTags(node), function (tag) { return !!tag.typeExpression; }); + } + return tag && tag.typeExpression && tag.typeExpression.type; + } + ts.getJSDocType = getJSDocType; + function getJSDocReturnType(node) { + var returnTag = getJSDocReturnTag(node); + if (returnTag && returnTag.typeExpression) { + return returnTag.typeExpression.type; + } + var typeTag = getJSDocTypeTag(node); + if (typeTag && typeTag.typeExpression) { + var type = typeTag.typeExpression.type; + if (isTypeLiteralNode(type)) { + var sig = ts.find(type.members, isCallSignatureDeclaration); + return sig && sig.type; + } + if (isFunctionTypeNode(type)) { + return type.type; + } + } + } + ts.getJSDocReturnType = getJSDocReturnType; + function getJSDocTags(node) { + var tags = node.jsDocCache; + if (tags === undefined) { + var comments = ts.getJSDocCommentsAndTags(node); + ts.Debug.assert(comments.length < 2 || comments[0] !== comments[1]); + node.jsDocCache = tags = ts.flatMap(comments, function (j) { return isJSDoc(j) ? j.tags : j; }); + } + return tags; + } + ts.getJSDocTags = getJSDocTags; + function getFirstJSDocTag(node, predicate) { + return ts.find(getJSDocTags(node), predicate); + } + function getAllJSDocTagsOfKind(node, kind) { + return getJSDocTags(node).filter(function (doc) { return doc.kind === kind; }); + } + ts.getAllJSDocTagsOfKind = getAllJSDocTagsOfKind; + function getEffectiveTypeParameterDeclarations(node) { + if (isJSDocSignature(node)) { + return ts.emptyArray; + } + if (ts.isJSDocTypeAlias(node)) { + ts.Debug.assert(node.parent.kind === 303); + return ts.flatMap(node.parent.tags, function (tag) { return isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; }); + } + if (node.typeParameters) { + return node.typeParameters; + } + if (ts.isInJSFile(node)) { + var decls = ts.getJSDocTypeParameterDeclarations(node); + if (decls.length) { + return decls; + } + var typeTag = getJSDocType(node); + if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) { + return typeTag.typeParameters; + } + } + return ts.emptyArray; + } + ts.getEffectiveTypeParameterDeclarations = getEffectiveTypeParameterDeclarations; + function getEffectiveConstraintOfTypeParameter(node) { + return node.constraint ? node.constraint : + isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint : + undefined; + } + ts.getEffectiveConstraintOfTypeParameter = getEffectiveConstraintOfTypeParameter; + function isNumericLiteral(node) { + return node.kind === 8; + } + ts.isNumericLiteral = isNumericLiteral; + function isBigIntLiteral(node) { + return node.kind === 9; + } + ts.isBigIntLiteral = isBigIntLiteral; + function isStringLiteral(node) { + return node.kind === 10; + } + ts.isStringLiteral = isStringLiteral; + function isJsxText(node) { + return node.kind === 11; + } + ts.isJsxText = isJsxText; + function isRegularExpressionLiteral(node) { + return node.kind === 13; + } + ts.isRegularExpressionLiteral = isRegularExpressionLiteral; + function isNoSubstitutionTemplateLiteral(node) { + return node.kind === 14; + } + ts.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral; + function isTemplateHead(node) { + return node.kind === 15; + } + ts.isTemplateHead = isTemplateHead; + function isTemplateMiddle(node) { + return node.kind === 16; + } + ts.isTemplateMiddle = isTemplateMiddle; + function isTemplateTail(node) { + return node.kind === 17; + } + ts.isTemplateTail = isTemplateTail; + function isIdentifier(node) { + return node.kind === 75; + } + ts.isIdentifier = isIdentifier; + function isQualifiedName(node) { + return node.kind === 153; + } + ts.isQualifiedName = isQualifiedName; + function isComputedPropertyName(node) { + return node.kind === 154; + } + ts.isComputedPropertyName = isComputedPropertyName; + function isPrivateIdentifier(node) { + return node.kind === 76; + } + ts.isPrivateIdentifier = isPrivateIdentifier; + function isIdentifierOrPrivateIdentifier(node) { + return node.kind === 75 || node.kind === 76; + } + ts.isIdentifierOrPrivateIdentifier = isIdentifierOrPrivateIdentifier; + function isTypeParameterDeclaration(node) { + return node.kind === 155; + } + ts.isTypeParameterDeclaration = isTypeParameterDeclaration; + function isParameter(node) { + return node.kind === 156; + } + ts.isParameter = isParameter; + function isDecorator(node) { + return node.kind === 157; + } + ts.isDecorator = isDecorator; + function isPropertySignature(node) { + return node.kind === 158; + } + ts.isPropertySignature = isPropertySignature; + function isPropertyDeclaration(node) { + return node.kind === 159; + } + ts.isPropertyDeclaration = isPropertyDeclaration; + function isMethodSignature(node) { + return node.kind === 160; + } + ts.isMethodSignature = isMethodSignature; + function isMethodDeclaration(node) { + return node.kind === 161; + } + ts.isMethodDeclaration = isMethodDeclaration; + function isConstructorDeclaration(node) { + return node.kind === 162; + } + ts.isConstructorDeclaration = isConstructorDeclaration; + function isGetAccessorDeclaration(node) { + return node.kind === 163; + } + ts.isGetAccessorDeclaration = isGetAccessorDeclaration; + function isSetAccessorDeclaration(node) { + return node.kind === 164; + } + ts.isSetAccessorDeclaration = isSetAccessorDeclaration; + function isCallSignatureDeclaration(node) { + return node.kind === 165; + } + ts.isCallSignatureDeclaration = isCallSignatureDeclaration; + function isConstructSignatureDeclaration(node) { + return node.kind === 166; + } + ts.isConstructSignatureDeclaration = isConstructSignatureDeclaration; + function isIndexSignatureDeclaration(node) { + return node.kind === 167; + } + ts.isIndexSignatureDeclaration = isIndexSignatureDeclaration; + function isGetOrSetAccessorDeclaration(node) { + return node.kind === 164 || node.kind === 163; + } + ts.isGetOrSetAccessorDeclaration = isGetOrSetAccessorDeclaration; + function isTypePredicateNode(node) { + return node.kind === 168; + } + ts.isTypePredicateNode = isTypePredicateNode; + function isTypeReferenceNode(node) { + return node.kind === 169; + } + ts.isTypeReferenceNode = isTypeReferenceNode; + function isFunctionTypeNode(node) { + return node.kind === 170; + } + ts.isFunctionTypeNode = isFunctionTypeNode; + function isConstructorTypeNode(node) { + return node.kind === 171; + } + ts.isConstructorTypeNode = isConstructorTypeNode; + function isTypeQueryNode(node) { + return node.kind === 172; + } + ts.isTypeQueryNode = isTypeQueryNode; + function isTypeLiteralNode(node) { + return node.kind === 173; + } + ts.isTypeLiteralNode = isTypeLiteralNode; + function isArrayTypeNode(node) { + return node.kind === 174; + } + ts.isArrayTypeNode = isArrayTypeNode; + function isTupleTypeNode(node) { + return node.kind === 175; + } + ts.isTupleTypeNode = isTupleTypeNode; + function isUnionTypeNode(node) { + return node.kind === 178; + } + ts.isUnionTypeNode = isUnionTypeNode; + function isIntersectionTypeNode(node) { + return node.kind === 179; + } + ts.isIntersectionTypeNode = isIntersectionTypeNode; + function isConditionalTypeNode(node) { + return node.kind === 180; + } + ts.isConditionalTypeNode = isConditionalTypeNode; + function isInferTypeNode(node) { + return node.kind === 181; + } + ts.isInferTypeNode = isInferTypeNode; + function isParenthesizedTypeNode(node) { + return node.kind === 182; + } + ts.isParenthesizedTypeNode = isParenthesizedTypeNode; + function isThisTypeNode(node) { + return node.kind === 183; + } + ts.isThisTypeNode = isThisTypeNode; + function isTypeOperatorNode(node) { + return node.kind === 184; + } + ts.isTypeOperatorNode = isTypeOperatorNode; + function isIndexedAccessTypeNode(node) { + return node.kind === 185; + } + ts.isIndexedAccessTypeNode = isIndexedAccessTypeNode; + function isMappedTypeNode(node) { + return node.kind === 186; + } + ts.isMappedTypeNode = isMappedTypeNode; + function isLiteralTypeNode(node) { + return node.kind === 187; + } + ts.isLiteralTypeNode = isLiteralTypeNode; + function isImportTypeNode(node) { + return node.kind === 188; + } + ts.isImportTypeNode = isImportTypeNode; + function isObjectBindingPattern(node) { + return node.kind === 189; + } + ts.isObjectBindingPattern = isObjectBindingPattern; + function isArrayBindingPattern(node) { + return node.kind === 190; + } + ts.isArrayBindingPattern = isArrayBindingPattern; + function isBindingElement(node) { + return node.kind === 191; + } + ts.isBindingElement = isBindingElement; + function isArrayLiteralExpression(node) { + return node.kind === 192; + } + ts.isArrayLiteralExpression = isArrayLiteralExpression; + function isObjectLiteralExpression(node) { + return node.kind === 193; + } + ts.isObjectLiteralExpression = isObjectLiteralExpression; + function isPropertyAccessExpression(node) { + return node.kind === 194; + } + ts.isPropertyAccessExpression = isPropertyAccessExpression; + function isPropertyAccessChain(node) { + return isPropertyAccessExpression(node) && !!(node.flags & 32); + } + ts.isPropertyAccessChain = isPropertyAccessChain; + function isElementAccessExpression(node) { + return node.kind === 195; + } + ts.isElementAccessExpression = isElementAccessExpression; + function isElementAccessChain(node) { + return isElementAccessExpression(node) && !!(node.flags & 32); + } + ts.isElementAccessChain = isElementAccessChain; + function isCallExpression(node) { + return node.kind === 196; + } + ts.isCallExpression = isCallExpression; + function isCallChain(node) { + return isCallExpression(node) && !!(node.flags & 32); + } + ts.isCallChain = isCallChain; + function isOptionalChain(node) { + var kind = node.kind; + return !!(node.flags & 32) && + (kind === 194 + || kind === 195 + || kind === 196); + } + ts.isOptionalChain = isOptionalChain; + function isOptionalChainRoot(node) { + return isOptionalChain(node) && !!node.questionDotToken; + } + ts.isOptionalChainRoot = isOptionalChainRoot; + function isExpressionOfOptionalChainRoot(node) { + return isOptionalChainRoot(node.parent) && node.parent.expression === node; + } + ts.isExpressionOfOptionalChainRoot = isExpressionOfOptionalChainRoot; + function isOutermostOptionalChain(node) { + return !isOptionalChain(node.parent) + || isOptionalChainRoot(node.parent) + || node !== node.parent.expression; + } + ts.isOutermostOptionalChain = isOutermostOptionalChain; + function isNullishCoalesce(node) { + return node.kind === 209 && node.operatorToken.kind === 60; + } + ts.isNullishCoalesce = isNullishCoalesce; + function isNewExpression(node) { + return node.kind === 197; + } + ts.isNewExpression = isNewExpression; + function isTaggedTemplateExpression(node) { + return node.kind === 198; + } + ts.isTaggedTemplateExpression = isTaggedTemplateExpression; + function isTypeAssertion(node) { + return node.kind === 199; + } + ts.isTypeAssertion = isTypeAssertion; + function isConstTypeReference(node) { + return isTypeReferenceNode(node) && isIdentifier(node.typeName) && + node.typeName.escapedText === "const" && !node.typeArguments; + } + ts.isConstTypeReference = isConstTypeReference; + function isParenthesizedExpression(node) { + return node.kind === 200; + } + ts.isParenthesizedExpression = isParenthesizedExpression; + function skipPartiallyEmittedExpressions(node) { + while (node.kind === 325) { + node = node.expression; + } + return node; + } + ts.skipPartiallyEmittedExpressions = skipPartiallyEmittedExpressions; + function isFunctionExpression(node) { + return node.kind === 201; + } + ts.isFunctionExpression = isFunctionExpression; + function isArrowFunction(node) { + return node.kind === 202; + } + ts.isArrowFunction = isArrowFunction; + function isDeleteExpression(node) { + return node.kind === 203; + } + ts.isDeleteExpression = isDeleteExpression; + function isTypeOfExpression(node) { + return node.kind === 204; + } + ts.isTypeOfExpression = isTypeOfExpression; + function isVoidExpression(node) { + return node.kind === 205; + } + ts.isVoidExpression = isVoidExpression; + function isAwaitExpression(node) { + return node.kind === 206; + } + ts.isAwaitExpression = isAwaitExpression; + function isPrefixUnaryExpression(node) { + return node.kind === 207; + } + ts.isPrefixUnaryExpression = isPrefixUnaryExpression; + function isPostfixUnaryExpression(node) { + return node.kind === 208; + } + ts.isPostfixUnaryExpression = isPostfixUnaryExpression; + function isBinaryExpression(node) { + return node.kind === 209; + } + ts.isBinaryExpression = isBinaryExpression; + function isConditionalExpression(node) { + return node.kind === 210; + } + ts.isConditionalExpression = isConditionalExpression; + function isTemplateExpression(node) { + return node.kind === 211; + } + ts.isTemplateExpression = isTemplateExpression; + function isYieldExpression(node) { + return node.kind === 212; + } + ts.isYieldExpression = isYieldExpression; + function isSpreadElement(node) { + return node.kind === 213; + } + ts.isSpreadElement = isSpreadElement; + function isClassExpression(node) { + return node.kind === 214; + } + ts.isClassExpression = isClassExpression; + function isOmittedExpression(node) { + return node.kind === 215; + } + ts.isOmittedExpression = isOmittedExpression; + function isExpressionWithTypeArguments(node) { + return node.kind === 216; + } + ts.isExpressionWithTypeArguments = isExpressionWithTypeArguments; + function isAsExpression(node) { + return node.kind === 217; + } + ts.isAsExpression = isAsExpression; + function isNonNullExpression(node) { + return node.kind === 218; + } + ts.isNonNullExpression = isNonNullExpression; + function isMetaProperty(node) { + return node.kind === 219; + } + ts.isMetaProperty = isMetaProperty; + function isTemplateSpan(node) { + return node.kind === 221; + } + ts.isTemplateSpan = isTemplateSpan; + function isSemicolonClassElement(node) { + return node.kind === 222; + } + ts.isSemicolonClassElement = isSemicolonClassElement; + function isBlock(node) { + return node.kind === 223; + } + ts.isBlock = isBlock; + function isVariableStatement(node) { + return node.kind === 225; + } + ts.isVariableStatement = isVariableStatement; + function isEmptyStatement(node) { + return node.kind === 224; + } + ts.isEmptyStatement = isEmptyStatement; + function isExpressionStatement(node) { + return node.kind === 226; + } + ts.isExpressionStatement = isExpressionStatement; + function isIfStatement(node) { + return node.kind === 227; + } + ts.isIfStatement = isIfStatement; + function isDoStatement(node) { + return node.kind === 228; + } + ts.isDoStatement = isDoStatement; + function isWhileStatement(node) { + return node.kind === 229; + } + ts.isWhileStatement = isWhileStatement; + function isForStatement(node) { + return node.kind === 230; + } + ts.isForStatement = isForStatement; + function isForInStatement(node) { + return node.kind === 231; + } + ts.isForInStatement = isForInStatement; + function isForOfStatement(node) { + return node.kind === 232; + } + ts.isForOfStatement = isForOfStatement; + function isContinueStatement(node) { + return node.kind === 233; + } + ts.isContinueStatement = isContinueStatement; + function isBreakStatement(node) { + return node.kind === 234; + } + ts.isBreakStatement = isBreakStatement; + function isBreakOrContinueStatement(node) { + return node.kind === 234 || node.kind === 233; + } + ts.isBreakOrContinueStatement = isBreakOrContinueStatement; + function isReturnStatement(node) { + return node.kind === 235; + } + ts.isReturnStatement = isReturnStatement; + function isWithStatement(node) { + return node.kind === 236; + } + ts.isWithStatement = isWithStatement; + function isSwitchStatement(node) { + return node.kind === 237; + } + ts.isSwitchStatement = isSwitchStatement; + function isLabeledStatement(node) { + return node.kind === 238; + } + ts.isLabeledStatement = isLabeledStatement; + function isThrowStatement(node) { + return node.kind === 239; + } + ts.isThrowStatement = isThrowStatement; + function isTryStatement(node) { + return node.kind === 240; + } + ts.isTryStatement = isTryStatement; + function isDebuggerStatement(node) { + return node.kind === 241; + } + ts.isDebuggerStatement = isDebuggerStatement; + function isVariableDeclaration(node) { + return node.kind === 242; + } + ts.isVariableDeclaration = isVariableDeclaration; + function isVariableDeclarationList(node) { + return node.kind === 243; + } + ts.isVariableDeclarationList = isVariableDeclarationList; + function isFunctionDeclaration(node) { + return node.kind === 244; + } + ts.isFunctionDeclaration = isFunctionDeclaration; + function isClassDeclaration(node) { + return node.kind === 245; + } + ts.isClassDeclaration = isClassDeclaration; + function isInterfaceDeclaration(node) { + return node.kind === 246; + } + ts.isInterfaceDeclaration = isInterfaceDeclaration; + function isTypeAliasDeclaration(node) { + return node.kind === 247; + } + ts.isTypeAliasDeclaration = isTypeAliasDeclaration; + function isEnumDeclaration(node) { + return node.kind === 248; + } + ts.isEnumDeclaration = isEnumDeclaration; + function isModuleDeclaration(node) { + return node.kind === 249; + } + ts.isModuleDeclaration = isModuleDeclaration; + function isModuleBlock(node) { + return node.kind === 250; + } + ts.isModuleBlock = isModuleBlock; + function isCaseBlock(node) { + return node.kind === 251; + } + ts.isCaseBlock = isCaseBlock; + function isNamespaceExportDeclaration(node) { + return node.kind === 252; + } + ts.isNamespaceExportDeclaration = isNamespaceExportDeclaration; + function isImportEqualsDeclaration(node) { + return node.kind === 253; + } + ts.isImportEqualsDeclaration = isImportEqualsDeclaration; + function isImportDeclaration(node) { + return node.kind === 254; + } + ts.isImportDeclaration = isImportDeclaration; + function isImportClause(node) { + return node.kind === 255; + } + ts.isImportClause = isImportClause; + function isNamespaceImport(node) { + return node.kind === 256; + } + ts.isNamespaceImport = isNamespaceImport; + function isNamespaceExport(node) { + return node.kind === 262; + } + ts.isNamespaceExport = isNamespaceExport; + function isNamedExportBindings(node) { + return node.kind === 262 || node.kind === 261; + } + ts.isNamedExportBindings = isNamedExportBindings; + function isNamedImports(node) { + return node.kind === 257; + } + ts.isNamedImports = isNamedImports; + function isImportSpecifier(node) { + return node.kind === 258; + } + ts.isImportSpecifier = isImportSpecifier; + function isExportAssignment(node) { + return node.kind === 259; + } + ts.isExportAssignment = isExportAssignment; + function isExportDeclaration(node) { + return node.kind === 260; + } + ts.isExportDeclaration = isExportDeclaration; + function isNamedExports(node) { + return node.kind === 261; + } + ts.isNamedExports = isNamedExports; + function isExportSpecifier(node) { + return node.kind === 263; + } + ts.isExportSpecifier = isExportSpecifier; + function isMissingDeclaration(node) { + return node.kind === 264; + } + ts.isMissingDeclaration = isMissingDeclaration; + function isExternalModuleReference(node) { + return node.kind === 265; + } + ts.isExternalModuleReference = isExternalModuleReference; + function isJsxElement(node) { + return node.kind === 266; + } + ts.isJsxElement = isJsxElement; + function isJsxSelfClosingElement(node) { + return node.kind === 267; + } + ts.isJsxSelfClosingElement = isJsxSelfClosingElement; + function isJsxOpeningElement(node) { + return node.kind === 268; + } + ts.isJsxOpeningElement = isJsxOpeningElement; + function isJsxClosingElement(node) { + return node.kind === 269; + } + ts.isJsxClosingElement = isJsxClosingElement; + function isJsxFragment(node) { + return node.kind === 270; + } + ts.isJsxFragment = isJsxFragment; + function isJsxOpeningFragment(node) { + return node.kind === 271; + } + ts.isJsxOpeningFragment = isJsxOpeningFragment; + function isJsxClosingFragment(node) { + return node.kind === 272; + } + ts.isJsxClosingFragment = isJsxClosingFragment; + function isJsxAttribute(node) { + return node.kind === 273; + } + ts.isJsxAttribute = isJsxAttribute; + function isJsxAttributes(node) { + return node.kind === 274; + } + ts.isJsxAttributes = isJsxAttributes; + function isJsxSpreadAttribute(node) { + return node.kind === 275; + } + ts.isJsxSpreadAttribute = isJsxSpreadAttribute; + function isJsxExpression(node) { + return node.kind === 276; + } + ts.isJsxExpression = isJsxExpression; + function isCaseClause(node) { + return node.kind === 277; + } + ts.isCaseClause = isCaseClause; + function isDefaultClause(node) { + return node.kind === 278; + } + ts.isDefaultClause = isDefaultClause; + function isHeritageClause(node) { + return node.kind === 279; + } + ts.isHeritageClause = isHeritageClause; + function isCatchClause(node) { + return node.kind === 280; + } + ts.isCatchClause = isCatchClause; + function isPropertyAssignment(node) { + return node.kind === 281; + } + ts.isPropertyAssignment = isPropertyAssignment; + function isShorthandPropertyAssignment(node) { + return node.kind === 282; + } + ts.isShorthandPropertyAssignment = isShorthandPropertyAssignment; + function isSpreadAssignment(node) { + return node.kind === 283; + } + ts.isSpreadAssignment = isSpreadAssignment; + function isEnumMember(node) { + return node.kind === 284; + } + ts.isEnumMember = isEnumMember; + function isSourceFile(node) { + return node.kind === 290; + } + ts.isSourceFile = isSourceFile; + function isBundle(node) { + return node.kind === 291; + } + ts.isBundle = isBundle; + function isUnparsedSource(node) { + return node.kind === 292; + } + ts.isUnparsedSource = isUnparsedSource; + function isUnparsedPrepend(node) { + return node.kind === 286; + } + ts.isUnparsedPrepend = isUnparsedPrepend; + function isUnparsedTextLike(node) { + switch (node.kind) { + case 287: + case 288: + return true; + default: + return false; + } + } + ts.isUnparsedTextLike = isUnparsedTextLike; + function isUnparsedNode(node) { + return isUnparsedTextLike(node) || + node.kind === 285 || + node.kind === 289; + } + ts.isUnparsedNode = isUnparsedNode; + function isJSDocTypeExpression(node) { + return node.kind === 294; + } + ts.isJSDocTypeExpression = isJSDocTypeExpression; + function isJSDocAllType(node) { + return node.kind === 295; + } + ts.isJSDocAllType = isJSDocAllType; + function isJSDocUnknownType(node) { + return node.kind === 296; + } + ts.isJSDocUnknownType = isJSDocUnknownType; + function isJSDocNullableType(node) { + return node.kind === 297; + } + ts.isJSDocNullableType = isJSDocNullableType; + function isJSDocNonNullableType(node) { + return node.kind === 298; + } + ts.isJSDocNonNullableType = isJSDocNonNullableType; + function isJSDocOptionalType(node) { + return node.kind === 299; + } + ts.isJSDocOptionalType = isJSDocOptionalType; + function isJSDocFunctionType(node) { + return node.kind === 300; + } + ts.isJSDocFunctionType = isJSDocFunctionType; + function isJSDocVariadicType(node) { + return node.kind === 301; + } + ts.isJSDocVariadicType = isJSDocVariadicType; + function isJSDoc(node) { + return node.kind === 303; + } + ts.isJSDoc = isJSDoc; + function isJSDocAuthorTag(node) { + return node.kind === 308; + } + ts.isJSDocAuthorTag = isJSDocAuthorTag; + function isJSDocAugmentsTag(node) { + return node.kind === 307; + } + ts.isJSDocAugmentsTag = isJSDocAugmentsTag; + function isJSDocClassTag(node) { + return node.kind === 309; + } + ts.isJSDocClassTag = isJSDocClassTag; + function isJSDocPublicTag(node) { + return node.kind === 310; + } + ts.isJSDocPublicTag = isJSDocPublicTag; + function isJSDocPrivateTag(node) { + return node.kind === 311; + } + ts.isJSDocPrivateTag = isJSDocPrivateTag; + function isJSDocProtectedTag(node) { + return node.kind === 312; + } + ts.isJSDocProtectedTag = isJSDocProtectedTag; + function isJSDocReadonlyTag(node) { + return node.kind === 313; + } + ts.isJSDocReadonlyTag = isJSDocReadonlyTag; + function isJSDocEnumTag(node) { + return node.kind === 315; + } + ts.isJSDocEnumTag = isJSDocEnumTag; + function isJSDocThisTag(node) { + return node.kind === 318; + } + ts.isJSDocThisTag = isJSDocThisTag; + function isJSDocParameterTag(node) { + return node.kind === 316; + } + ts.isJSDocParameterTag = isJSDocParameterTag; + function isJSDocReturnTag(node) { + return node.kind === 317; + } + ts.isJSDocReturnTag = isJSDocReturnTag; + function isJSDocTypeTag(node) { + return node.kind === 319; + } + ts.isJSDocTypeTag = isJSDocTypeTag; + function isJSDocTemplateTag(node) { + return node.kind === 320; + } + ts.isJSDocTemplateTag = isJSDocTemplateTag; + function isJSDocTypedefTag(node) { + return node.kind === 321; + } + ts.isJSDocTypedefTag = isJSDocTypedefTag; + function isJSDocPropertyTag(node) { + return node.kind === 322; + } + ts.isJSDocPropertyTag = isJSDocPropertyTag; + function isJSDocPropertyLikeTag(node) { + return node.kind === 322 || node.kind === 316; + } + ts.isJSDocPropertyLikeTag = isJSDocPropertyLikeTag; + function isJSDocTypeLiteral(node) { + return node.kind === 304; + } + ts.isJSDocTypeLiteral = isJSDocTypeLiteral; + function isJSDocCallbackTag(node) { + return node.kind === 314; + } + ts.isJSDocCallbackTag = isJSDocCallbackTag; + function isJSDocSignature(node) { + return node.kind === 305; + } + ts.isJSDocSignature = isJSDocSignature; + function isSyntaxList(n) { + return n.kind === 323; + } + ts.isSyntaxList = isSyntaxList; + function isNode(node) { + return isNodeKind(node.kind); + } + ts.isNode = isNode; + function isNodeKind(kind) { + return kind >= 153; + } + ts.isNodeKind = isNodeKind; + function isToken(n) { + return n.kind >= 0 && n.kind <= 152; + } + ts.isToken = isToken; + function isNodeArray(array) { + return array.hasOwnProperty("pos") && array.hasOwnProperty("end"); + } + ts.isNodeArray = isNodeArray; + function isLiteralKind(kind) { + return 8 <= kind && kind <= 14; + } + ts.isLiteralKind = isLiteralKind; + function isLiteralExpression(node) { + return isLiteralKind(node.kind); + } + ts.isLiteralExpression = isLiteralExpression; + function isTemplateLiteralKind(kind) { + return 14 <= kind && kind <= 17; + } + ts.isTemplateLiteralKind = isTemplateLiteralKind; + function isTemplateLiteralToken(node) { + return isTemplateLiteralKind(node.kind); + } + ts.isTemplateLiteralToken = isTemplateLiteralToken; + function isTemplateMiddleOrTemplateTail(node) { + var kind = node.kind; + return kind === 16 + || kind === 17; + } + ts.isTemplateMiddleOrTemplateTail = isTemplateMiddleOrTemplateTail; + function isImportOrExportSpecifier(node) { + return isImportSpecifier(node) || isExportSpecifier(node); + } + ts.isImportOrExportSpecifier = isImportOrExportSpecifier; + function isTypeOnlyImportOrExportDeclaration(node) { + switch (node.kind) { + case 258: + case 263: + return node.parent.parent.isTypeOnly; + case 256: + return node.parent.isTypeOnly; + case 255: + return node.isTypeOnly; + default: + return false; + } + } + ts.isTypeOnlyImportOrExportDeclaration = isTypeOnlyImportOrExportDeclaration; + function isStringTextContainingNode(node) { + return node.kind === 10 || isTemplateLiteralKind(node.kind); + } + ts.isStringTextContainingNode = isStringTextContainingNode; + function isGeneratedIdentifier(node) { + return isIdentifier(node) && (node.autoGenerateFlags & 7) > 0; + } + ts.isGeneratedIdentifier = isGeneratedIdentifier; + function isPrivateIdentifierPropertyDeclaration(node) { + return isPropertyDeclaration(node) && isPrivateIdentifier(node.name); + } + ts.isPrivateIdentifierPropertyDeclaration = isPrivateIdentifierPropertyDeclaration; + function isPrivateIdentifierPropertyAccessExpression(node) { + return isPropertyAccessExpression(node) && isPrivateIdentifier(node.name); + } + ts.isPrivateIdentifierPropertyAccessExpression = isPrivateIdentifierPropertyAccessExpression; + function isModifierKind(token) { + switch (token) { + case 122: + case 126: + case 81: + case 130: + case 84: + case 89: + case 119: + case 117: + case 118: + case 138: + case 120: + return true; + } + return false; + } + ts.isModifierKind = isModifierKind; + function isParameterPropertyModifier(kind) { + return !!(ts.modifierToFlag(kind) & 92); + } + ts.isParameterPropertyModifier = isParameterPropertyModifier; + function isClassMemberModifier(idToken) { + return isParameterPropertyModifier(idToken) || idToken === 120; + } + ts.isClassMemberModifier = isClassMemberModifier; + function isModifier(node) { + return isModifierKind(node.kind); + } + ts.isModifier = isModifier; + function isEntityName(node) { + var kind = node.kind; + return kind === 153 + || kind === 75; + } + ts.isEntityName = isEntityName; + function isPropertyName(node) { + var kind = node.kind; + return kind === 75 + || kind === 10 + || kind === 8 + || kind === 154; + } + ts.isPropertyName = isPropertyName; + function isBindingName(node) { + var kind = node.kind; + return kind === 75 + || kind === 189 + || kind === 190; + } + ts.isBindingName = isBindingName; + function isFunctionLike(node) { + return node && isFunctionLikeKind(node.kind); + } + ts.isFunctionLike = isFunctionLike; + function isFunctionLikeDeclaration(node) { + return node && isFunctionLikeDeclarationKind(node.kind); + } + ts.isFunctionLikeDeclaration = isFunctionLikeDeclaration; + function isFunctionLikeDeclarationKind(kind) { + switch (kind) { + case 244: + case 161: + case 162: + case 163: + case 164: + case 201: + case 202: + return true; + default: + return false; + } + } + function isFunctionLikeKind(kind) { + switch (kind) { + case 160: + case 165: + case 305: + case 166: + case 167: + case 170: + case 300: + case 171: + return true; + default: + return isFunctionLikeDeclarationKind(kind); + } + } + ts.isFunctionLikeKind = isFunctionLikeKind; + function isFunctionOrModuleBlock(node) { + return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent); + } + ts.isFunctionOrModuleBlock = isFunctionOrModuleBlock; + function isClassElement(node) { + var kind = node.kind; + return kind === 162 + || kind === 159 + || kind === 161 + || kind === 163 + || kind === 164 + || kind === 167 + || kind === 222; + } + ts.isClassElement = isClassElement; + function isClassLike(node) { + return node && (node.kind === 245 || node.kind === 214); + } + ts.isClassLike = isClassLike; + function isAccessor(node) { + return node && (node.kind === 163 || node.kind === 164); + } + ts.isAccessor = isAccessor; + function isMethodOrAccessor(node) { + switch (node.kind) { + case 161: + case 163: + case 164: + return true; + default: + return false; + } + } + ts.isMethodOrAccessor = isMethodOrAccessor; + function isTypeElement(node) { + var kind = node.kind; + return kind === 166 + || kind === 165 + || kind === 158 + || kind === 160 + || kind === 167; + } + ts.isTypeElement = isTypeElement; + function isClassOrTypeElement(node) { + return isTypeElement(node) || isClassElement(node); + } + ts.isClassOrTypeElement = isClassOrTypeElement; + function isObjectLiteralElementLike(node) { + var kind = node.kind; + return kind === 281 + || kind === 282 + || kind === 283 + || kind === 161 + || kind === 163 + || kind === 164; + } + ts.isObjectLiteralElementLike = isObjectLiteralElementLike; + function isTypeNode(node) { + return ts.isTypeNodeKind(node.kind); + } + ts.isTypeNode = isTypeNode; + function isFunctionOrConstructorTypeNode(node) { + switch (node.kind) { + case 170: + case 171: + return true; + } + return false; + } + ts.isFunctionOrConstructorTypeNode = isFunctionOrConstructorTypeNode; + function isBindingPattern(node) { + if (node) { + var kind = node.kind; + return kind === 190 + || kind === 189; + } + return false; + } + ts.isBindingPattern = isBindingPattern; + function isAssignmentPattern(node) { + var kind = node.kind; + return kind === 192 + || kind === 193; + } + ts.isAssignmentPattern = isAssignmentPattern; + function isArrayBindingElement(node) { + var kind = node.kind; + return kind === 191 + || kind === 215; + } + ts.isArrayBindingElement = isArrayBindingElement; + function isDeclarationBindingElement(bindingElement) { + switch (bindingElement.kind) { + case 242: + case 156: + case 191: + return true; + } + return false; + } + ts.isDeclarationBindingElement = isDeclarationBindingElement; + function isBindingOrAssignmentPattern(node) { + return isObjectBindingOrAssignmentPattern(node) + || isArrayBindingOrAssignmentPattern(node); + } + ts.isBindingOrAssignmentPattern = isBindingOrAssignmentPattern; + function isObjectBindingOrAssignmentPattern(node) { + switch (node.kind) { + case 189: + case 193: + return true; + } + return false; + } + ts.isObjectBindingOrAssignmentPattern = isObjectBindingOrAssignmentPattern; + function isArrayBindingOrAssignmentPattern(node) { + switch (node.kind) { + case 190: + case 192: + return true; + } + return false; + } + ts.isArrayBindingOrAssignmentPattern = isArrayBindingOrAssignmentPattern; + function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) { + var kind = node.kind; + return kind === 194 + || kind === 153 + || kind === 188; + } + ts.isPropertyAccessOrQualifiedNameOrImportTypeNode = isPropertyAccessOrQualifiedNameOrImportTypeNode; + function isPropertyAccessOrQualifiedName(node) { + var kind = node.kind; + return kind === 194 + || kind === 153; + } + ts.isPropertyAccessOrQualifiedName = isPropertyAccessOrQualifiedName; + function isCallLikeExpression(node) { + switch (node.kind) { + case 268: + case 267: + case 196: + case 197: + case 198: + case 157: + return true; + default: + return false; + } + } + ts.isCallLikeExpression = isCallLikeExpression; + function isCallOrNewExpression(node) { + return node.kind === 196 || node.kind === 197; + } + ts.isCallOrNewExpression = isCallOrNewExpression; + function isTemplateLiteral(node) { + var kind = node.kind; + return kind === 211 + || kind === 14; + } + ts.isTemplateLiteral = isTemplateLiteral; + function isLeftHandSideExpression(node) { + return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isLeftHandSideExpression = isLeftHandSideExpression; + function isLeftHandSideExpressionKind(kind) { + switch (kind) { + case 194: + case 195: + case 197: + case 196: + case 266: + case 267: + case 270: + case 198: + case 192: + case 200: + case 193: + case 214: + case 201: + case 75: + case 13: + case 8: + case 9: + case 10: + case 14: + case 211: + case 91: + case 100: + case 104: + case 106: + case 102: + case 218: + case 219: + case 96: + return true; + default: + return false; + } + } + function isUnaryExpression(node) { + return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isUnaryExpression = isUnaryExpression; + function isUnaryExpressionKind(kind) { + switch (kind) { + case 207: + case 208: + case 203: + case 204: + case 205: + case 206: + case 199: + return true; + default: + return isLeftHandSideExpressionKind(kind); + } + } + function isUnaryExpressionWithWrite(expr) { + switch (expr.kind) { + case 208: + return true; + case 207: + return expr.operator === 45 || + expr.operator === 46; + default: + return false; + } + } + ts.isUnaryExpressionWithWrite = isUnaryExpressionWithWrite; + function isExpression(node) { + return isExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isExpression = isExpression; + function isExpressionKind(kind) { + switch (kind) { + case 210: + case 212: + case 202: + case 209: + case 213: + case 217: + case 215: + case 326: + case 325: + return true; + default: + return isUnaryExpressionKind(kind); + } + } + function isAssertionExpression(node) { + var kind = node.kind; + return kind === 199 + || kind === 217; + } + ts.isAssertionExpression = isAssertionExpression; + function isPartiallyEmittedExpression(node) { + return node.kind === 325; + } + ts.isPartiallyEmittedExpression = isPartiallyEmittedExpression; + function isNotEmittedStatement(node) { + return node.kind === 324; + } + ts.isNotEmittedStatement = isNotEmittedStatement; + function isSyntheticReference(node) { + return node.kind === 329; + } + ts.isSyntheticReference = isSyntheticReference; + function isNotEmittedOrPartiallyEmittedNode(node) { + return isNotEmittedStatement(node) + || isPartiallyEmittedExpression(node); + } + ts.isNotEmittedOrPartiallyEmittedNode = isNotEmittedOrPartiallyEmittedNode; + function isIterationStatement(node, lookInLabeledStatements) { + switch (node.kind) { + case 230: + case 231: + case 232: + case 228: + case 229: + return true; + case 238: + return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); + } + return false; + } + ts.isIterationStatement = isIterationStatement; + function isScopeMarker(node) { + return isExportAssignment(node) || isExportDeclaration(node); + } + ts.isScopeMarker = isScopeMarker; + function hasScopeMarker(statements) { + return ts.some(statements, isScopeMarker); + } + ts.hasScopeMarker = hasScopeMarker; + function needsScopeMarker(result) { + return !ts.isAnyImportOrReExport(result) && !isExportAssignment(result) && !ts.hasModifier(result, 1) && !ts.isAmbientModule(result); + } + ts.needsScopeMarker = needsScopeMarker; + function isExternalModuleIndicator(result) { + return ts.isAnyImportOrReExport(result) || isExportAssignment(result) || ts.hasModifier(result, 1); + } + ts.isExternalModuleIndicator = isExternalModuleIndicator; + function isForInOrOfStatement(node) { + return node.kind === 231 || node.kind === 232; + } + ts.isForInOrOfStatement = isForInOrOfStatement; + function isConciseBody(node) { + return isBlock(node) + || isExpression(node); + } + ts.isConciseBody = isConciseBody; + function isFunctionBody(node) { + return isBlock(node); + } + ts.isFunctionBody = isFunctionBody; + function isForInitializer(node) { + return isVariableDeclarationList(node) + || isExpression(node); + } + ts.isForInitializer = isForInitializer; + function isModuleBody(node) { + var kind = node.kind; + return kind === 250 + || kind === 249 + || kind === 75; + } + ts.isModuleBody = isModuleBody; + function isNamespaceBody(node) { + var kind = node.kind; + return kind === 250 + || kind === 249; + } + ts.isNamespaceBody = isNamespaceBody; + function isJSDocNamespaceBody(node) { + var kind = node.kind; + return kind === 75 + || kind === 249; + } + ts.isJSDocNamespaceBody = isJSDocNamespaceBody; + function isNamedImportBindings(node) { + var kind = node.kind; + return kind === 257 + || kind === 256; + } + ts.isNamedImportBindings = isNamedImportBindings; + function isModuleOrEnumDeclaration(node) { + return node.kind === 249 || node.kind === 248; + } + ts.isModuleOrEnumDeclaration = isModuleOrEnumDeclaration; + function isDeclarationKind(kind) { + return kind === 202 + || kind === 191 + || kind === 245 + || kind === 214 + || kind === 162 + || kind === 248 + || kind === 284 + || kind === 263 + || kind === 244 + || kind === 201 + || kind === 163 + || kind === 255 + || kind === 253 + || kind === 258 + || kind === 246 + || kind === 273 + || kind === 161 + || kind === 160 + || kind === 249 + || kind === 252 + || kind === 256 + || kind === 262 + || kind === 156 + || kind === 281 + || kind === 159 + || kind === 158 + || kind === 164 + || kind === 282 + || kind === 247 + || kind === 155 + || kind === 242 + || kind === 321 + || kind === 314 + || kind === 322; + } + function isDeclarationStatementKind(kind) { + return kind === 244 + || kind === 264 + || kind === 245 + || kind === 246 + || kind === 247 + || kind === 248 + || kind === 249 + || kind === 254 + || kind === 253 + || kind === 260 + || kind === 259 + || kind === 252; + } + function isStatementKindButNotDeclarationKind(kind) { + return kind === 234 + || kind === 233 + || kind === 241 + || kind === 228 + || kind === 226 + || kind === 224 + || kind === 231 + || kind === 232 + || kind === 230 + || kind === 227 + || kind === 238 + || kind === 235 + || kind === 237 + || kind === 239 + || kind === 240 + || kind === 225 + || kind === 229 + || kind === 236 + || kind === 324 + || kind === 328 + || kind === 327; + } + function isDeclaration(node) { + if (node.kind === 155) { + return (node.parent && node.parent.kind !== 320) || ts.isInJSFile(node); + } + return isDeclarationKind(node.kind); + } + ts.isDeclaration = isDeclaration; + function isDeclarationStatement(node) { + return isDeclarationStatementKind(node.kind); + } + ts.isDeclarationStatement = isDeclarationStatement; + function isStatementButNotDeclaration(node) { + return isStatementKindButNotDeclarationKind(node.kind); + } + ts.isStatementButNotDeclaration = isStatementButNotDeclaration; + function isStatement(node) { + var kind = node.kind; + return isStatementKindButNotDeclarationKind(kind) + || isDeclarationStatementKind(kind) + || isBlockStatement(node); + } + ts.isStatement = isStatement; + function isBlockStatement(node) { + if (node.kind !== 223) + return false; + if (node.parent !== undefined) { + if (node.parent.kind === 240 || node.parent.kind === 280) { + return false; + } + } + return !ts.isFunctionBlock(node); + } + function isModuleReference(node) { + var kind = node.kind; + return kind === 265 + || kind === 153 + || kind === 75; + } + ts.isModuleReference = isModuleReference; + function isJsxTagNameExpression(node) { + var kind = node.kind; + return kind === 104 + || kind === 75 + || kind === 194; + } + ts.isJsxTagNameExpression = isJsxTagNameExpression; + function isJsxChild(node) { + var kind = node.kind; + return kind === 266 + || kind === 276 + || kind === 267 + || kind === 11 + || kind === 270; + } + ts.isJsxChild = isJsxChild; + function isJsxAttributeLike(node) { + var kind = node.kind; + return kind === 273 + || kind === 275; + } + ts.isJsxAttributeLike = isJsxAttributeLike; + function isStringLiteralOrJsxExpression(node) { + var kind = node.kind; + return kind === 10 + || kind === 276; + } + ts.isStringLiteralOrJsxExpression = isStringLiteralOrJsxExpression; + function isJsxOpeningLikeElement(node) { + var kind = node.kind; + return kind === 268 + || kind === 267; + } + ts.isJsxOpeningLikeElement = isJsxOpeningLikeElement; + function isCaseOrDefaultClause(node) { + var kind = node.kind; + return kind === 277 + || kind === 278; + } + ts.isCaseOrDefaultClause = isCaseOrDefaultClause; + function isJSDocNode(node) { + return node.kind >= 294 && node.kind <= 322; + } + ts.isJSDocNode = isJSDocNode; + function isJSDocCommentContainingNode(node) { + return node.kind === 303 || isJSDocTag(node) || isJSDocTypeLiteral(node) || isJSDocSignature(node); + } + ts.isJSDocCommentContainingNode = isJSDocCommentContainingNode; + function isJSDocTag(node) { + return node.kind >= 306 && node.kind <= 322; + } + ts.isJSDocTag = isJSDocTag; + function isSetAccessor(node) { + return node.kind === 164; + } + ts.isSetAccessor = isSetAccessor; + function isGetAccessor(node) { + return node.kind === 163; + } + ts.isGetAccessor = isGetAccessor; + function hasJSDocNodes(node) { + var jsDoc = node.jsDoc; + return !!jsDoc && jsDoc.length > 0; + } + ts.hasJSDocNodes = hasJSDocNodes; + function hasType(node) { + return !!node.type; + } + ts.hasType = hasType; + function hasInitializer(node) { + return !!node.initializer; + } + ts.hasInitializer = hasInitializer; + function hasOnlyExpressionInitializer(node) { + return hasInitializer(node) && !isForStatement(node) && !isForInStatement(node) && !isForOfStatement(node) && !isJsxAttribute(node); + } + ts.hasOnlyExpressionInitializer = hasOnlyExpressionInitializer; + function isObjectLiteralElement(node) { + return node.kind === 273 || node.kind === 275 || isObjectLiteralElementLike(node); + } + ts.isObjectLiteralElement = isObjectLiteralElement; + function isTypeReferenceType(node) { + return node.kind === 169 || node.kind === 216; + } + ts.isTypeReferenceType = isTypeReferenceType; + var MAX_SMI_X86 = 1073741823; + function guessIndentation(lines) { + var indentation = MAX_SMI_X86; + for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) { + var line = lines_1[_i]; + if (!line.length) { + continue; + } + var i = 0; + for (; i < line.length && i < indentation; i++) { + if (!ts.isWhiteSpaceLike(line.charCodeAt(i))) { + break; + } + } + if (i < indentation) { + indentation = i; + } + if (indentation === 0) { + return 0; + } + } + return indentation === MAX_SMI_X86 ? undefined : indentation; + } + ts.guessIndentation = guessIndentation; + function isStringLiteralLike(node) { + return node.kind === 10 || node.kind === 14; + } + ts.isStringLiteralLike = isStringLiteralLike; +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.resolvingEmptyArray = []; + ts.emptyMap = ts.createMap(); + ts.emptyUnderscoreEscapedMap = ts.emptyMap; + ts.externalHelpersModuleNameText = "tslib"; + ts.defaultMaximumTruncationLength = 160; + function getDeclarationOfKind(symbol, kind) { + var declarations = symbol.declarations; + if (declarations) { + for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) { + var declaration = declarations_1[_i]; + if (declaration.kind === kind) { + return declaration; + } + } + } + return undefined; + } + ts.getDeclarationOfKind = getDeclarationOfKind; + function createUnderscoreEscapedMap() { + return new ts.Map(); + } + ts.createUnderscoreEscapedMap = createUnderscoreEscapedMap; + function hasEntries(map) { + return !!map && !!map.size; + } + ts.hasEntries = hasEntries; + function createSymbolTable(symbols) { + var result = ts.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 isTransientSymbol(symbol) { + return (symbol.flags & 33554432) !== 0; + } + ts.isTransientSymbol = isTransientSymbol; + var stringWriter = createSingleLineStringWriter(); + function createSingleLineStringWriter() { + var str = ""; + var writeText = function (text) { return str += text; }; + return { + getText: function () { return str; }, + write: writeText, + rawWrite: writeText, + writeKeyword: writeText, + writeOperator: writeText, + writePunctuation: writeText, + writeSpace: writeText, + writeStringLiteral: writeText, + writeLiteral: writeText, + writeParameter: writeText, + writeProperty: writeText, + writeSymbol: function (s, _) { return writeText(s); }, + writeTrailingSemicolon: writeText, + writeComment: writeText, + getTextPos: function () { return str.length; }, + getLine: function () { return 0; }, + getColumn: function () { return 0; }, + getIndent: function () { return 0; }, + isAtStartOfLine: function () { return false; }, + hasTrailingComment: function () { return false; }, + hasTrailingWhitespace: function () { return !!str.length && ts.isWhiteSpaceLike(str.charCodeAt(str.length - 1)); }, + writeLine: function () { return str += " "; }, + increaseIndent: ts.noop, + decreaseIndent: ts.noop, + clear: function () { return str = ""; }, + trackSymbol: ts.noop, + reportInaccessibleThisError: ts.noop, + reportInaccessibleUniqueSymbolError: ts.noop, + reportPrivateInBaseOfClassExpression: ts.noop, + }; + } + function changesAffectModuleResolution(oldOptions, newOptions) { + return oldOptions.configFilePath !== newOptions.configFilePath || + optionsHaveModuleResolutionChanges(oldOptions, newOptions); + } + ts.changesAffectModuleResolution = changesAffectModuleResolution; + function optionsHaveModuleResolutionChanges(oldOptions, newOptions) { + return ts.moduleResolutionOptionDeclarations.some(function (o) { + return !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)); + }); + } + ts.optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges; + 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 forEachAncestor(node, callback) { + while (true) { + var res = callback(node); + if (res === "quit") + return undefined; + if (res !== undefined) + return res; + if (ts.isSourceFile(node)) + return undefined; + node = node.parent; + } + } + ts.forEachAncestor = forEachAncestor; + function forEachEntry(map, callback) { + var iterator = map.entries(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + var _a = iterResult.value, key = _a[0], value = _a[1]; + var result = callback(value, key); + if (result) { + return result; + } + } + return undefined; + } + ts.forEachEntry = forEachEntry; + function forEachKey(map, callback) { + var iterator = map.keys(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + var result = callback(iterResult.value); + if (result) { + return result; + } + } + return undefined; + } + ts.forEachKey = forEachKey; + function copyEntries(source, target) { + source.forEach(function (value, key) { + target.set(key, value); + }); + } + ts.copyEntries = copyEntries; + function arrayToSet(array, makeKey) { + return ts.arrayToMap(array, makeKey || (function (s) { return s; }), ts.returnTrue); + } + ts.arrayToSet = arrayToSet; + function cloneMap(map) { + var clone = ts.createMap(); + copyEntries(map, clone); + return clone; + } + ts.cloneMap = cloneMap; + function usingSingleLineStringWriter(action) { + var oldString = stringWriter.getText(); + try { + action(stringWriter); + return stringWriter.getText(); + } + finally { + stringWriter.clear(); + stringWriter.writeKeyword(oldString); + } + } + ts.usingSingleLineStringWriter = usingSingleLineStringWriter; + function getFullWidth(node) { + return node.end - node.pos; + } + ts.getFullWidth = getFullWidth; + function getResolvedModule(sourceFile, moduleNameText) { + return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText); + } + ts.getResolvedModule = getResolvedModule; + function setResolvedModule(sourceFile, moduleNameText, resolvedModule) { + if (!sourceFile.resolvedModules) { + sourceFile.resolvedModules = ts.createMap(); + } + sourceFile.resolvedModules.set(moduleNameText, resolvedModule); + } + ts.setResolvedModule = setResolvedModule; + function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) { + if (!sourceFile.resolvedTypeReferenceDirectiveNames) { + sourceFile.resolvedTypeReferenceDirectiveNames = ts.createMap(); + } + sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective); + } + ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective; + function projectReferenceIsEqualTo(oldRef, newRef) { + return oldRef.path === newRef.path && + !oldRef.prepend === !newRef.prepend && + !oldRef.circular === !newRef.circular; + } + ts.projectReferenceIsEqualTo = projectReferenceIsEqualTo; + function moduleResolutionIsEqualTo(oldResolution, newResolution) { + return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport && + oldResolution.extension === newResolution.extension && + oldResolution.resolvedFileName === newResolution.resolvedFileName && + oldResolution.originalPath === newResolution.originalPath && + packageIdIsEqual(oldResolution.packageId, newResolution.packageId); + } + ts.moduleResolutionIsEqualTo = moduleResolutionIsEqualTo; + function packageIdIsEqual(a, b) { + return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version; + } + function packageIdToString(_a) { + var name = _a.name, subModuleName = _a.subModuleName, version = _a.version; + var fullName = subModuleName ? name + "/" + subModuleName : name; + return fullName + "@" + version; + } + ts.packageIdToString = packageIdToString; + function typeDirectiveIsEqualTo(oldResolution, newResolution) { + return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary; + } + ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo; + function hasChangesInResolutions(names, newResolutions, oldResolutions, comparer) { + ts.Debug.assert(names.length === newResolutions.length); + for (var i = 0; i < names.length; i++) { + var newResolution = newResolutions[i]; + var oldResolution = oldResolutions && oldResolutions.get(names[i]); + var changed = oldResolution + ? !newResolution || !comparer(oldResolution, newResolution) + : newResolution; + if (changed) { + return true; + } + } + return false; + } + ts.hasChangesInResolutions = hasChangesInResolutions; + function containsParseError(node) { + aggregateChildData(node); + return (node.flags & 262144) !== 0; + } + ts.containsParseError = containsParseError; + function aggregateChildData(node) { + if (!(node.flags & 524288)) { + var thisNodeOrAnySubNodesHasError = ((node.flags & 65536) !== 0) || + ts.forEachChild(node, containsParseError); + if (thisNodeOrAnySubNodesHasError) { + node.flags |= 262144; + } + node.flags |= 524288; + } + } + function getSourceFileOfNode(node) { + while (node && node.kind !== 290) { + node = node.parent; + } + return node; + } + ts.getSourceFileOfNode = getSourceFileOfNode; + function isStatementWithLocals(node) { + switch (node.kind) { + case 223: + case 251: + case 230: + case 231: + case 232: + return true; + } + return false; + } + ts.isStatementWithLocals = isStatementWithLocals; + function getStartPositionOfLine(line, sourceFile) { + ts.Debug.assert(line >= 0); + return ts.getLineStarts(sourceFile)[line]; + } + ts.getStartPositionOfLine = getStartPositionOfLine; + function nodePosToString(node) { + var file = getSourceFileOfNode(node); + var loc = ts.getLineAndCharacterOfPosition(file, node.pos); + return file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + ")"; + } + ts.nodePosToString = nodePosToString; + function getEndLinePosition(line, sourceFile) { + ts.Debug.assert(line >= 0); + var lineStarts = ts.getLineStarts(sourceFile); + var lineIndex = line; + var sourceText = sourceFile.text; + if (lineIndex + 1 === lineStarts.length) { + return sourceText.length - 1; + } + else { + var start = lineStarts[lineIndex]; + var pos = lineStarts[lineIndex + 1] - 1; + ts.Debug.assert(ts.isLineBreak(sourceText.charCodeAt(pos))); + while (start <= pos && ts.isLineBreak(sourceText.charCodeAt(pos))) { + pos--; + } + return pos; + } + } + ts.getEndLinePosition = getEndLinePosition; + function isFileLevelUniqueName(sourceFile, name, hasGlobalName) { + return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name); + } + ts.isFileLevelUniqueName = isFileLevelUniqueName; + function nodeIsMissing(node) { + if (node === undefined) { + return true; + } + return node.pos === node.end && node.pos >= 0 && node.kind !== 1; + } + ts.nodeIsMissing = nodeIsMissing; + function nodeIsPresent(node) { + return !nodeIsMissing(node); + } + ts.nodeIsPresent = nodeIsPresent; + function insertStatementsAfterPrologue(to, from, isPrologueDirective) { + if (from === undefined || from.length === 0) + return to; + var statementIndex = 0; + for (; statementIndex < to.length; ++statementIndex) { + if (!isPrologueDirective(to[statementIndex])) { + break; + } + } + to.splice.apply(to, __spreadArrays([statementIndex, 0], from)); + return to; + } + function insertStatementAfterPrologue(to, statement, isPrologueDirective) { + if (statement === undefined) + return to; + var statementIndex = 0; + for (; statementIndex < to.length; ++statementIndex) { + if (!isPrologueDirective(to[statementIndex])) { + break; + } + } + to.splice(statementIndex, 0, statement); + return to; + } + function isAnyPrologueDirective(node) { + return isPrologueDirective(node) || !!(getEmitFlags(node) & 1048576); + } + function insertStatementsAfterStandardPrologue(to, from) { + return insertStatementsAfterPrologue(to, from, isPrologueDirective); + } + ts.insertStatementsAfterStandardPrologue = insertStatementsAfterStandardPrologue; + function insertStatementsAfterCustomPrologue(to, from) { + return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective); + } + ts.insertStatementsAfterCustomPrologue = insertStatementsAfterCustomPrologue; + function insertStatementAfterStandardPrologue(to, statement) { + return insertStatementAfterPrologue(to, statement, isPrologueDirective); + } + ts.insertStatementAfterStandardPrologue = insertStatementAfterStandardPrologue; + function insertStatementAfterCustomPrologue(to, statement) { + return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective); + } + ts.insertStatementAfterCustomPrologue = insertStatementAfterCustomPrologue; + function isRecognizedTripleSlashComment(text, commentPos, commentEnd) { + if (text.charCodeAt(commentPos + 1) === 47 && + commentPos + 2 < commentEnd && + text.charCodeAt(commentPos + 2) === 47) { + var textSubStr = text.substring(commentPos, commentEnd); + return textSubStr.match(ts.fullTripleSlashReferencePathRegEx) || + textSubStr.match(ts.fullTripleSlashAMDReferencePathRegEx) || + textSubStr.match(fullTripleSlashReferenceTypeReferenceDirectiveRegEx) || + textSubStr.match(defaultLibReferenceRegEx) ? + true : false; + } + return false; + } + ts.isRecognizedTripleSlashComment = isRecognizedTripleSlashComment; + function isPinnedComment(text, start) { + return text.charCodeAt(start + 1) === 42 && + text.charCodeAt(start + 2) === 33; + } + ts.isPinnedComment = isPinnedComment; + function getTokenPosOfNode(node, sourceFile, includeJsDoc) { + if (nodeIsMissing(node)) { + return node.pos; + } + if (ts.isJSDocNode(node)) { + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, false, true); + } + if (includeJsDoc && ts.hasJSDocNodes(node)) { + return getTokenPosOfNode(node.jsDoc[0]); + } + if (node.kind === 323 && node._children.length > 0) { + return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc); + } + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos); + } + ts.getTokenPosOfNode = getTokenPosOfNode; + function getNonDecoratorTokenPosOfNode(node, sourceFile) { + if (nodeIsMissing(node) || !node.decorators) { + return getTokenPosOfNode(node, sourceFile); + } + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end); + } + ts.getNonDecoratorTokenPosOfNode = getNonDecoratorTokenPosOfNode; + function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia); + } + ts.getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile; + function isJSDocTypeExpressionOrChild(node) { + return !!findAncestor(node, ts.isJSDocTypeExpression); + } + function getTextOfNodeFromSourceText(sourceText, node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + if (nodeIsMissing(node)) { + return ""; + } + var text = sourceText.substring(includeTrivia ? node.pos : ts.skipTrivia(sourceText, node.pos), node.end); + if (isJSDocTypeExpressionOrChild(node)) { + text = text.replace(/(^|\r?\n|\r)\s*\*\s*/g, "$1"); + } + return text; + } + ts.getTextOfNodeFromSourceText = getTextOfNodeFromSourceText; + function getTextOfNode(node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); + } + ts.getTextOfNode = getTextOfNode; + function getPos(range) { + return range.pos; + } + function indexOfNode(nodeArray, node) { + return ts.binarySearch(nodeArray, node, getPos, ts.compareValues); + } + ts.indexOfNode = indexOfNode; + function getEmitFlags(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.flags || 0; + } + ts.getEmitFlags = getEmitFlags; + function getLiteralText(node, sourceFile, neverAsciiEscape, jsxAttributeEscape) { + if (!nodeIsSynthesized(node) && node.parent && !((ts.isNumericLiteral(node) && node.numericLiteralFlags & 512) || + ts.isBigIntLiteral(node))) { + return getSourceTextOfNodeFromSourceFile(sourceFile, node); + } + switch (node.kind) { + case 10: { + var escapeText = jsxAttributeEscape ? escapeJsxAttributeString : + neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString : + escapeNonAsciiString; + if (node.singleQuote) { + return "'" + escapeText(node.text, 39) + "'"; + } + else { + return '"' + escapeText(node.text, 34) + '"'; + } + } + case 14: + case 15: + case 16: + case 17: { + var escapeText = neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString : + escapeNonAsciiString; + var rawText = node.rawText || escapeTemplateSubstitution(escapeText(node.text, 96)); + switch (node.kind) { + case 14: + return "`" + rawText + "`"; + case 15: + return "`" + rawText + "${"; + case 16: + return "}" + rawText + "${"; + case 17: + return "}" + rawText + "`"; + } + break; + } + case 8: + case 9: + case 13: + return node.text; + } + return ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for."); + } + ts.getLiteralText = getLiteralText; + function getTextOfConstantValue(value) { + return ts.isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value; + } + ts.getTextOfConstantValue = getTextOfConstantValue; + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; + function isBlockOrCatchScoped(declaration) { + return (ts.getCombinedNodeFlags(declaration) & 3) !== 0 || + isCatchClauseVariableDeclarationOrBindingElement(declaration); + } + ts.isBlockOrCatchScoped = isBlockOrCatchScoped; + function isCatchClauseVariableDeclarationOrBindingElement(declaration) { + var node = getRootDeclaration(declaration); + return node.kind === 242 && node.parent.kind === 280; + } + ts.isCatchClauseVariableDeclarationOrBindingElement = isCatchClauseVariableDeclarationOrBindingElement; + function isAmbientModule(node) { + return ts.isModuleDeclaration(node) && (node.name.kind === 10 || isGlobalScopeAugmentation(node)); + } + ts.isAmbientModule = isAmbientModule; + function isModuleWithStringLiteralName(node) { + return ts.isModuleDeclaration(node) && node.name.kind === 10; + } + ts.isModuleWithStringLiteralName = isModuleWithStringLiteralName; + function isNonGlobalAmbientModule(node) { + return ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name); + } + ts.isNonGlobalAmbientModule = isNonGlobalAmbientModule; + function isEffectiveModuleDeclaration(node) { + return ts.isModuleDeclaration(node) || ts.isIdentifier(node); + } + ts.isEffectiveModuleDeclaration = isEffectiveModuleDeclaration; + function isShorthandAmbientModuleSymbol(moduleSymbol) { + return isShorthandAmbientModule(moduleSymbol.valueDeclaration); + } + ts.isShorthandAmbientModuleSymbol = isShorthandAmbientModuleSymbol; + function isShorthandAmbientModule(node) { + return node && node.kind === 249 && (!node.body); + } + function isBlockScopedContainerTopLevel(node) { + return node.kind === 290 || + node.kind === 249 || + ts.isFunctionLike(node); + } + ts.isBlockScopedContainerTopLevel = isBlockScopedContainerTopLevel; + function isGlobalScopeAugmentation(module) { + return !!(module.flags & 1024); + } + ts.isGlobalScopeAugmentation = isGlobalScopeAugmentation; + function isExternalModuleAugmentation(node) { + return isAmbientModule(node) && isModuleAugmentationExternal(node); + } + ts.isExternalModuleAugmentation = isExternalModuleAugmentation; + function isModuleAugmentationExternal(node) { + switch (node.parent.kind) { + case 290: + return ts.isExternalModule(node.parent); + case 250: + return isAmbientModule(node.parent.parent) && ts.isSourceFile(node.parent.parent.parent) && !ts.isExternalModule(node.parent.parent.parent); + } + return false; + } + ts.isModuleAugmentationExternal = isModuleAugmentationExternal; + function getNonAugmentationDeclaration(symbol) { + return ts.find(symbol.declarations, function (d) { return !isExternalModuleAugmentation(d) && !(ts.isModuleDeclaration(d) && isGlobalScopeAugmentation(d)); }); + } + ts.getNonAugmentationDeclaration = getNonAugmentationDeclaration; + function isEffectiveExternalModule(node, compilerOptions) { + return ts.isExternalModule(node) || compilerOptions.isolatedModules || ((getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS) && !!node.commonJsModuleIndicator); + } + ts.isEffectiveExternalModule = isEffectiveExternalModule; + function isEffectiveStrictModeSourceFile(node, compilerOptions) { + switch (node.scriptKind) { + case 1: + case 3: + case 2: + case 4: + break; + default: + return false; + } + if (node.isDeclarationFile) { + return false; + } + if (getStrictOptionValue(compilerOptions, "alwaysStrict")) { + return true; + } + if (ts.startsWithUseStrict(node.statements)) { + return true; + } + if (ts.isExternalModule(node) || compilerOptions.isolatedModules) { + if (getEmitModuleKind(compilerOptions) >= ts.ModuleKind.ES2015) { + return true; + } + return !compilerOptions.noImplicitUseStrict; + } + return false; + } + ts.isEffectiveStrictModeSourceFile = isEffectiveStrictModeSourceFile; + function isBlockScope(node, parentNode) { + switch (node.kind) { + case 290: + case 251: + case 280: + case 249: + case 230: + case 231: + case 232: + case 162: + case 161: + case 163: + case 164: + case 244: + case 201: + case 202: + return true; + case 223: + return !ts.isFunctionLike(parentNode); + } + return false; + } + ts.isBlockScope = isBlockScope; + function isDeclarationWithTypeParameters(node) { + switch (node.kind) { + case 314: + case 321: + case 305: + return true; + default: + ts.assertType(node); + return isDeclarationWithTypeParameterChildren(node); + } + } + ts.isDeclarationWithTypeParameters = isDeclarationWithTypeParameters; + function isDeclarationWithTypeParameterChildren(node) { + switch (node.kind) { + case 165: + case 166: + case 160: + case 167: + case 170: + case 171: + case 300: + case 245: + case 214: + case 246: + case 247: + case 320: + case 244: + case 161: + case 162: + case 163: + case 164: + case 201: + case 202: + return true; + default: + ts.assertType(node); + return false; + } + } + ts.isDeclarationWithTypeParameterChildren = isDeclarationWithTypeParameterChildren; + function isAnyImportSyntax(node) { + switch (node.kind) { + case 254: + case 253: + return true; + default: + return false; + } + } + ts.isAnyImportSyntax = isAnyImportSyntax; + function isLateVisibilityPaintedStatement(node) { + switch (node.kind) { + case 254: + case 253: + case 225: + case 245: + case 244: + case 249: + case 247: + case 246: + case 248: + return true; + default: + return false; + } + } + ts.isLateVisibilityPaintedStatement = isLateVisibilityPaintedStatement; + function isAnyImportOrReExport(node) { + return isAnyImportSyntax(node) || ts.isExportDeclaration(node); + } + ts.isAnyImportOrReExport = isAnyImportOrReExport; + function getEnclosingBlockScopeContainer(node) { + return findAncestor(node.parent, function (current) { return isBlockScope(current, current.parent); }); + } + ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; + function declarationNameToString(name) { + return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); + } + ts.declarationNameToString = declarationNameToString; + function getNameFromIndexInfo(info) { + return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined; + } + ts.getNameFromIndexInfo = getNameFromIndexInfo; + function getTextOfPropertyName(name) { + switch (name.kind) { + case 75: + case 76: + return name.escapedText; + case 10: + case 8: + case 14: + return ts.escapeLeadingUnderscores(name.text); + case 154: + if (isStringOrNumericLiteralLike(name.expression)) + return ts.escapeLeadingUnderscores(name.expression.text); + return ts.Debug.fail("Text of property name cannot be read from non-literal-valued ComputedPropertyNames"); + default: + return ts.Debug.assertNever(name); + } + } + ts.getTextOfPropertyName = getTextOfPropertyName; + function entityNameToString(name) { + switch (name.kind) { + case 75: + return getFullWidth(name) === 0 ? ts.idText(name) : getTextOfNode(name); + case 153: + return entityNameToString(name.left) + "." + entityNameToString(name.right); + case 194: + if (ts.isIdentifier(name.name)) { + return entityNameToString(name.expression) + "." + entityNameToString(name.name); + } + else { + return ts.Debug.assertNever(name.name); + } + default: + return ts.Debug.assertNever(name); + } + } + ts.entityNameToString = entityNameToString; + function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) { + var sourceFile = getSourceFileOfNode(node); + return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNode = createDiagnosticForNode; + function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) { + var start = ts.skipTrivia(sourceFile.text, nodes.pos); + return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNodeArray = createDiagnosticForNodeArray; + function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) { + var span = getErrorSpanForNode(sourceFile, node); + return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNodeInSourceFile = createDiagnosticForNodeInSourceFile; + function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) { + var sourceFile = getSourceFileOfNode(node); + var span = getErrorSpanForNode(sourceFile, node); + return { + file: sourceFile, + start: span.start, + length: span.length, + code: messageChain.code, + category: messageChain.category, + messageText: messageChain.next ? messageChain : messageChain.messageText, + relatedInformation: relatedInformation + }; + } + ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; + function getSpanOfTokenAtPosition(sourceFile, pos) { + var scanner = ts.createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, undefined, pos); + scanner.scan(); + var start = scanner.getTokenPos(); + return ts.createTextSpanFromBounds(start, scanner.getTextPos()); + } + ts.getSpanOfTokenAtPosition = getSpanOfTokenAtPosition; + function getErrorSpanForArrowFunction(sourceFile, node) { + var pos = ts.skipTrivia(sourceFile.text, node.pos); + if (node.body && node.body.kind === 223) { + var startLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.pos).line; + var endLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.end).line; + if (startLine < endLine) { + return ts.createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1); + } + } + return ts.createTextSpanFromBounds(pos, node.end); + } + function getErrorSpanForNode(sourceFile, node) { + var errorNode = node; + switch (node.kind) { + case 290: + var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); + if (pos_1 === sourceFile.text.length) { + return ts.createTextSpan(0, 0); + } + return getSpanOfTokenAtPosition(sourceFile, pos_1); + case 242: + case 191: + case 245: + case 214: + case 246: + case 249: + case 248: + case 284: + case 244: + case 201: + case 161: + case 163: + case 164: + case 247: + case 159: + case 158: + errorNode = node.name; + break; + case 202: + return getErrorSpanForArrowFunction(sourceFile, node); + case 277: + case 278: + var start = ts.skipTrivia(sourceFile.text, node.pos); + var end = node.statements.length > 0 ? node.statements[0].pos : node.end; + return ts.createTextSpanFromBounds(start, end); + } + if (errorNode === undefined) { + return getSpanOfTokenAtPosition(sourceFile, node.pos); + } + ts.Debug.assert(!ts.isJSDoc(errorNode)); + var isMissing = nodeIsMissing(errorNode); + var pos = isMissing || ts.isJsxText(node) + ? errorNode.pos + : ts.skipTrivia(sourceFile.text, errorNode.pos); + if (isMissing) { + ts.Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + ts.Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + } + else { + ts.Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + ts.Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + } + return ts.createTextSpanFromBounds(pos, errorNode.end); + } + ts.getErrorSpanForNode = getErrorSpanForNode; + function isExternalOrCommonJsModule(file) { + return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined; + } + ts.isExternalOrCommonJsModule = isExternalOrCommonJsModule; + function isJsonSourceFile(file) { + return file.scriptKind === 6; + } + ts.isJsonSourceFile = isJsonSourceFile; + function isEnumConst(node) { + return !!(ts.getCombinedModifierFlags(node) & 2048); + } + ts.isEnumConst = isEnumConst; + function isDeclarationReadonly(declaration) { + return !!(ts.getCombinedModifierFlags(declaration) & 64 && !ts.isParameterPropertyDeclaration(declaration, declaration.parent)); + } + ts.isDeclarationReadonly = isDeclarationReadonly; + function isVarConst(node) { + return !!(ts.getCombinedNodeFlags(node) & 2); + } + ts.isVarConst = isVarConst; + function isLet(node) { + return !!(ts.getCombinedNodeFlags(node) & 1); + } + ts.isLet = isLet; + function isSuperCall(n) { + return n.kind === 196 && n.expression.kind === 102; + } + ts.isSuperCall = isSuperCall; + function isImportCall(n) { + return n.kind === 196 && n.expression.kind === 96; + } + ts.isImportCall = isImportCall; + function isImportMeta(n) { + return ts.isMetaProperty(n) + && n.keywordToken === 96 + && n.name.escapedText === "meta"; + } + ts.isImportMeta = isImportMeta; + function isLiteralImportTypeNode(n) { + return ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument) && ts.isStringLiteral(n.argument.literal); + } + ts.isLiteralImportTypeNode = isLiteralImportTypeNode; + function isPrologueDirective(node) { + return node.kind === 226 + && node.expression.kind === 10; + } + ts.isPrologueDirective = isPrologueDirective; + function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { + return node.kind !== 11 ? ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : undefined; + } + ts.getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode; + function getJSDocCommentRanges(node, text) { + var commentRanges = (node.kind === 156 || + node.kind === 155 || + node.kind === 201 || + node.kind === 202 || + node.kind === 200) ? + ts.concatenate(ts.getTrailingCommentRanges(text, node.pos), ts.getLeadingCommentRanges(text, node.pos)) : + ts.getLeadingCommentRanges(text, node.pos); + return ts.filter(commentRanges, function (comment) { + return text.charCodeAt(comment.pos + 1) === 42 && + text.charCodeAt(comment.pos + 2) === 42 && + text.charCodeAt(comment.pos + 3) !== 47; + }); + } + ts.getJSDocCommentRanges = getJSDocCommentRanges; + ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; + var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*/; + ts.fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*/; + var defaultLibReferenceRegEx = /^(\/\/\/\s*/; + function isPartOfTypeNode(node) { + if (168 <= node.kind && node.kind <= 188) { + return true; + } + switch (node.kind) { + case 125: + case 148: + case 140: + case 151: + case 143: + case 128: + case 144: + case 141: + case 146: + case 137: + return true; + case 110: + return node.parent.kind !== 205; + case 216: + return !isExpressionWithTypeArgumentsInClassExtendsClause(node); + case 155: + return node.parent.kind === 186 || node.parent.kind === 181; + case 75: + if (node.parent.kind === 153 && node.parent.right === node) { + node = node.parent; + } + else if (node.parent.kind === 194 && node.parent.name === node) { + node = node.parent; + } + ts.Debug.assert(node.kind === 75 || node.kind === 153 || node.kind === 194, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."); + case 153: + case 194: + case 104: { + var parent = node.parent; + if (parent.kind === 172) { + return false; + } + if (parent.kind === 188) { + return !parent.isTypeOf; + } + if (168 <= parent.kind && parent.kind <= 188) { + return true; + } + switch (parent.kind) { + case 216: + return !isExpressionWithTypeArgumentsInClassExtendsClause(parent); + case 155: + return node === parent.constraint; + case 320: + return node === parent.constraint; + case 159: + case 158: + case 156: + case 242: + return node === parent.type; + case 244: + case 201: + case 202: + case 162: + case 161: + case 160: + case 163: + case 164: + return node === parent.type; + case 165: + case 166: + case 167: + return node === parent.type; + case 199: + return node === parent.type; + case 196: + case 197: + return ts.contains(parent.typeArguments, node); + case 198: + return false; + } + } + } + return false; + } + ts.isPartOfTypeNode = isPartOfTypeNode; + function isChildOfNodeWithKind(node, kind) { + while (node) { + if (node.kind === kind) { + return true; + } + node = node.parent; + } + return false; + } + ts.isChildOfNodeWithKind = isChildOfNodeWithKind; + function forEachReturnStatement(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case 235: + return visitor(node); + case 251: + case 223: + case 227: + case 228: + case 229: + case 230: + case 231: + case 232: + case 236: + case 237: + case 277: + case 278: + case 238: + case 240: + case 280: + return ts.forEachChild(node, traverse); + } + } + } + ts.forEachReturnStatement = forEachReturnStatement; + function forEachYieldExpression(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case 212: + visitor(node); + var operand = node.expression; + if (operand) { + traverse(operand); + } + return; + case 248: + case 246: + case 249: + case 247: + return; + default: + if (ts.isFunctionLike(node)) { + if (node.name && node.name.kind === 154) { + traverse(node.name.expression); + return; + } + } + else if (!isPartOfTypeNode(node)) { + ts.forEachChild(node, traverse); + } + } + } + } + ts.forEachYieldExpression = forEachYieldExpression; + function getRestParameterElementType(node) { + if (node && node.kind === 174) { + return node.elementType; + } + else if (node && node.kind === 169) { + return ts.singleOrUndefined(node.typeArguments); + } + else { + return undefined; + } + } + ts.getRestParameterElementType = getRestParameterElementType; + function getMembersOfDeclaration(node) { + switch (node.kind) { + case 246: + case 245: + case 214: + case 173: + return node.members; + case 193: + return node.properties; + } + } + ts.getMembersOfDeclaration = getMembersOfDeclaration; + function isVariableLike(node) { + if (node) { + switch (node.kind) { + case 191: + case 284: + case 156: + case 281: + case 159: + case 158: + case 282: + case 242: + return true; + } + } + return false; + } + ts.isVariableLike = isVariableLike; + function isVariableLikeOrAccessor(node) { + return isVariableLike(node) || ts.isAccessor(node); + } + ts.isVariableLikeOrAccessor = isVariableLikeOrAccessor; + function isVariableDeclarationInVariableStatement(node) { + return node.parent.kind === 243 + && node.parent.parent.kind === 225; + } + ts.isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement; + function isValidESSymbolDeclaration(node) { + return ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) : + ts.isPropertyDeclaration(node) ? hasReadonlyModifier(node) && hasStaticModifier(node) : + ts.isPropertySignature(node) && hasReadonlyModifier(node); + } + ts.isValidESSymbolDeclaration = isValidESSymbolDeclaration; + function introducesArgumentsExoticObject(node) { + switch (node.kind) { + case 161: + case 160: + case 162: + case 163: + case 164: + case 244: + case 201: + return true; + } + return false; + } + ts.introducesArgumentsExoticObject = introducesArgumentsExoticObject; + function unwrapInnermostStatementOfLabel(node, beforeUnwrapLabelCallback) { + while (true) { + if (beforeUnwrapLabelCallback) { + beforeUnwrapLabelCallback(node); + } + if (node.statement.kind !== 238) { + return node.statement; + } + node = node.statement; + } + } + ts.unwrapInnermostStatementOfLabel = unwrapInnermostStatementOfLabel; + function isFunctionBlock(node) { + return node && node.kind === 223 && ts.isFunctionLike(node.parent); + } + ts.isFunctionBlock = isFunctionBlock; + function isObjectLiteralMethod(node) { + return node && node.kind === 161 && node.parent.kind === 193; + } + ts.isObjectLiteralMethod = isObjectLiteralMethod; + function isObjectLiteralOrClassExpressionMethod(node) { + return node.kind === 161 && + (node.parent.kind === 193 || + node.parent.kind === 214); + } + ts.isObjectLiteralOrClassExpressionMethod = isObjectLiteralOrClassExpressionMethod; + function isIdentifierTypePredicate(predicate) { + return predicate && predicate.kind === 1; + } + ts.isIdentifierTypePredicate = isIdentifierTypePredicate; + function isThisTypePredicate(predicate) { + return predicate && predicate.kind === 0; + } + ts.isThisTypePredicate = isThisTypePredicate; + function getPropertyAssignment(objectLiteral, key, key2) { + return objectLiteral.properties.filter(function (property) { + if (property.kind === 281) { + var propName = getTextOfPropertyName(property.name); + return key === propName || (!!key2 && key2 === propName); + } + return false; + }); + } + ts.getPropertyAssignment = getPropertyAssignment; + function getTsConfigObjectLiteralExpression(tsConfigSourceFile) { + if (tsConfigSourceFile && tsConfigSourceFile.statements.length) { + var expression = tsConfigSourceFile.statements[0].expression; + return ts.tryCast(expression, ts.isObjectLiteralExpression); + } + } + ts.getTsConfigObjectLiteralExpression = getTsConfigObjectLiteralExpression; + function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) { + return ts.firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), function (property) { + return ts.isArrayLiteralExpression(property.initializer) ? + ts.find(property.initializer.elements, function (element) { return ts.isStringLiteral(element) && element.text === elementValue; }) : + undefined; + }); + } + ts.getTsConfigPropArrayElementValue = getTsConfigPropArrayElementValue; + function getTsConfigPropArray(tsConfigSourceFile, propKey) { + var jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile); + return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : ts.emptyArray; + } + ts.getTsConfigPropArray = getTsConfigPropArray; + function getContainingFunction(node) { + return findAncestor(node.parent, ts.isFunctionLike); + } + ts.getContainingFunction = getContainingFunction; + function getContainingFunctionDeclaration(node) { + return findAncestor(node.parent, ts.isFunctionLikeDeclaration); + } + ts.getContainingFunctionDeclaration = getContainingFunctionDeclaration; + function getContainingClass(node) { + return findAncestor(node.parent, ts.isClassLike); + } + ts.getContainingClass = getContainingClass; + function getThisContainer(node, includeArrowFunctions) { + ts.Debug.assert(node.kind !== 290); + while (true) { + node = node.parent; + if (!node) { + return ts.Debug.fail(); + } + switch (node.kind) { + case 154: + if (ts.isClassLike(node.parent.parent)) { + return node; + } + node = node.parent; + break; + case 157: + if (node.parent.kind === 156 && ts.isClassElement(node.parent.parent)) { + node = node.parent.parent; + } + else if (ts.isClassElement(node.parent)) { + node = node.parent; + } + break; + case 202: + if (!includeArrowFunctions) { + continue; + } + case 244: + case 201: + case 249: + case 159: + case 158: + case 161: + case 160: + case 162: + case 163: + case 164: + case 165: + case 166: + case 167: + case 248: + case 290: + return node; + } + } + } + ts.getThisContainer = getThisContainer; + function getNewTargetContainer(node) { + var container = getThisContainer(node, false); + if (container) { + switch (container.kind) { + case 162: + case 244: + case 201: + return container; + } + } + return undefined; + } + ts.getNewTargetContainer = getNewTargetContainer; + function getSuperContainer(node, stopOnFunctions) { + while (true) { + node = node.parent; + if (!node) { + return node; + } + switch (node.kind) { + case 154: + node = node.parent; + break; + case 244: + case 201: + case 202: + if (!stopOnFunctions) { + continue; + } + case 159: + case 158: + case 161: + case 160: + case 162: + case 163: + case 164: + return node; + case 157: + if (node.parent.kind === 156 && ts.isClassElement(node.parent.parent)) { + node = node.parent.parent; + } + else if (ts.isClassElement(node.parent)) { + node = node.parent; + } + break; + } + } + } + ts.getSuperContainer = getSuperContainer; + function getImmediatelyInvokedFunctionExpression(func) { + if (func.kind === 201 || func.kind === 202) { + var prev = func; + var parent = func.parent; + while (parent.kind === 200) { + prev = parent; + parent = parent.parent; + } + if (parent.kind === 196 && parent.expression === prev) { + return parent; + } + } + } + ts.getImmediatelyInvokedFunctionExpression = getImmediatelyInvokedFunctionExpression; + function isSuperOrSuperProperty(node) { + return node.kind === 102 + || isSuperProperty(node); + } + ts.isSuperOrSuperProperty = isSuperOrSuperProperty; + function isSuperProperty(node) { + var kind = node.kind; + return (kind === 194 || kind === 195) + && node.expression.kind === 102; + } + ts.isSuperProperty = isSuperProperty; + function isThisProperty(node) { + var kind = node.kind; + return (kind === 194 || kind === 195) + && node.expression.kind === 104; + } + ts.isThisProperty = isThisProperty; + function getEntityNameFromTypeNode(node) { + switch (node.kind) { + case 169: + return node.typeName; + case 216: + return isEntityNameExpression(node.expression) + ? node.expression + : undefined; + case 75: + case 153: + return node; + } + return undefined; + } + ts.getEntityNameFromTypeNode = getEntityNameFromTypeNode; + function getInvokedExpression(node) { + switch (node.kind) { + case 198: + return node.tag; + case 268: + case 267: + return node.tagName; + default: + return node.expression; + } + } + ts.getInvokedExpression = getInvokedExpression; + function nodeCanBeDecorated(node, parent, grandparent) { + if (ts.isNamedDeclaration(node) && ts.isPrivateIdentifier(node.name)) { + return false; + } + switch (node.kind) { + case 245: + return true; + case 159: + return parent.kind === 245; + case 163: + case 164: + case 161: + return node.body !== undefined + && parent.kind === 245; + case 156: + return parent.body !== undefined + && (parent.kind === 162 + || parent.kind === 161 + || parent.kind === 164) + && grandparent.kind === 245; + } + return false; + } + ts.nodeCanBeDecorated = nodeCanBeDecorated; + function nodeIsDecorated(node, parent, grandparent) { + return node.decorators !== undefined + && nodeCanBeDecorated(node, parent, grandparent); + } + ts.nodeIsDecorated = nodeIsDecorated; + function nodeOrChildIsDecorated(node, parent, grandparent) { + return nodeIsDecorated(node, parent, grandparent) || childIsDecorated(node, parent); + } + ts.nodeOrChildIsDecorated = nodeOrChildIsDecorated; + function childIsDecorated(node, parent) { + switch (node.kind) { + case 245: + return ts.some(node.members, function (m) { return nodeOrChildIsDecorated(m, node, parent); }); + case 161: + case 164: + return ts.some(node.parameters, function (p) { return nodeIsDecorated(p, node, parent); }); + default: + return false; + } + } + ts.childIsDecorated = childIsDecorated; + function isJSXTagName(node) { + var parent = node.parent; + if (parent.kind === 268 || + parent.kind === 267 || + parent.kind === 269) { + return parent.tagName === node; + } + return false; + } + ts.isJSXTagName = isJSXTagName; + function isExpressionNode(node) { + switch (node.kind) { + case 102: + case 100: + case 106: + case 91: + case 13: + case 192: + case 193: + case 194: + case 195: + case 196: + case 197: + case 198: + case 217: + case 199: + case 218: + case 200: + case 201: + case 214: + case 202: + case 205: + case 203: + case 204: + case 207: + case 208: + case 209: + case 210: + case 213: + case 211: + case 215: + case 266: + case 267: + case 270: + case 212: + case 206: + case 219: + return true; + case 153: + while (node.parent.kind === 153) { + node = node.parent; + } + return node.parent.kind === 172 || isJSXTagName(node); + case 75: + if (node.parent.kind === 172 || isJSXTagName(node)) { + return true; + } + case 8: + case 9: + case 10: + case 14: + case 104: + return isInExpressionContext(node); + default: + return false; + } + } + ts.isExpressionNode = isExpressionNode; + function isInExpressionContext(node) { + var parent = node.parent; + switch (parent.kind) { + case 242: + case 156: + case 159: + case 158: + case 284: + case 281: + case 191: + return parent.initializer === node; + case 226: + case 227: + case 228: + case 229: + case 235: + case 236: + case 237: + case 277: + case 239: + return parent.expression === node; + case 230: + var forStatement = parent; + return (forStatement.initializer === node && forStatement.initializer.kind !== 243) || + forStatement.condition === node || + forStatement.incrementor === node; + case 231: + case 232: + var forInStatement = parent; + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 243) || + forInStatement.expression === node; + case 199: + case 217: + return node === parent.expression; + case 221: + return node === parent.expression; + case 154: + return node === parent.expression; + case 157: + case 276: + case 275: + case 283: + return true; + case 216: + return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent); + case 282: + return parent.objectAssignmentInitializer === node; + default: + return isExpressionNode(parent); + } + } + ts.isInExpressionContext = isInExpressionContext; + function isPartOfTypeQuery(node) { + while (node.kind === 153 || node.kind === 75) { + node = node.parent; + } + return node.kind === 172; + } + ts.isPartOfTypeQuery = isPartOfTypeQuery; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 253 && node.moduleReference.kind === 265; + } + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); + return node.moduleReference.expression; + } + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 253 && node.moduleReference.kind !== 265; + } + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function isSourceFileJS(file) { + return isInJSFile(file); + } + ts.isSourceFileJS = isSourceFileJS; + function isSourceFileNotJS(file) { + return !isInJSFile(file); + } + ts.isSourceFileNotJS = isSourceFileNotJS; + function isInJSFile(node) { + return !!node && !!(node.flags & 131072); + } + ts.isInJSFile = isInJSFile; + function isInJsonFile(node) { + return !!node && !!(node.flags & 33554432); + } + ts.isInJsonFile = isInJsonFile; + function isSourceFileNotJson(file) { + return !isJsonSourceFile(file); + } + ts.isSourceFileNotJson = isSourceFileNotJson; + function isInJSDoc(node) { + return !!node && !!(node.flags & 4194304); + } + ts.isInJSDoc = isInJSDoc; + function isJSDocIndexSignature(node) { + return ts.isTypeReferenceNode(node) && + ts.isIdentifier(node.typeName) && + node.typeName.escapedText === "Object" && + node.typeArguments && node.typeArguments.length === 2 && + (node.typeArguments[0].kind === 143 || node.typeArguments[0].kind === 140); + } + ts.isJSDocIndexSignature = isJSDocIndexSignature; + function isRequireCall(callExpression, requireStringLiteralLikeArgument) { + if (callExpression.kind !== 196) { + return false; + } + var _a = callExpression, expression = _a.expression, args = _a.arguments; + if (expression.kind !== 75 || expression.escapedText !== "require") { + return false; + } + if (args.length !== 1) { + return false; + } + var arg = args[0]; + return !requireStringLiteralLikeArgument || ts.isStringLiteralLike(arg); + } + ts.isRequireCall = isRequireCall; + function isSingleOrDoubleQuote(charCode) { + return charCode === 39 || charCode === 34; + } + ts.isSingleOrDoubleQuote = isSingleOrDoubleQuote; + function isStringDoubleQuoted(str, sourceFile) { + return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34; + } + ts.isStringDoubleQuoted = isStringDoubleQuoted; + function getDeclarationOfExpando(node) { + if (!node.parent) { + return undefined; + } + var name; + var decl; + if (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) { + if (!isInJSFile(node) && !isVarConst(node.parent)) { + return undefined; + } + name = node.parent.name; + decl = node.parent; + } + else if (ts.isBinaryExpression(node.parent)) { + var parentNode = node.parent; + var parentNodeOperator = node.parent.operatorToken.kind; + if (parentNodeOperator === 62 && parentNode.right === node) { + name = parentNode.left; + decl = name; + } + else if (parentNodeOperator === 56 || parentNodeOperator === 60) { + if (ts.isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) { + name = parentNode.parent.name; + decl = parentNode.parent; + } + else if (ts.isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 62 && parentNode.parent.right === parentNode) { + name = parentNode.parent.left; + decl = name; + } + if (!name || !isBindableStaticNameExpression(name) || !isSameEntityName(name, parentNode.left)) { + return undefined; + } + } + } + if (!name || !getExpandoInitializer(node, isPrototypeAccess(name))) { + return undefined; + } + return decl; + } + ts.getDeclarationOfExpando = getDeclarationOfExpando; + function isAssignmentDeclaration(decl) { + return ts.isBinaryExpression(decl) || isAccessExpression(decl) || ts.isIdentifier(decl) || ts.isCallExpression(decl); + } + ts.isAssignmentDeclaration = isAssignmentDeclaration; + function getEffectiveInitializer(node) { + if (isInJSFile(node) && node.initializer && + ts.isBinaryExpression(node.initializer) && + (node.initializer.operatorToken.kind === 56 || node.initializer.operatorToken.kind === 60) && + node.name && isEntityNameExpression(node.name) && isSameEntityName(node.name, node.initializer.left)) { + return node.initializer.right; + } + return node.initializer; + } + ts.getEffectiveInitializer = getEffectiveInitializer; + function getDeclaredExpandoInitializer(node) { + var init = getEffectiveInitializer(node); + return init && getExpandoInitializer(init, isPrototypeAccess(node.name)); + } + ts.getDeclaredExpandoInitializer = getDeclaredExpandoInitializer; + function hasExpandoValueProperty(node, isPrototypeAssignment) { + return ts.forEach(node.properties, function (p) { + return ts.isPropertyAssignment(p) && + ts.isIdentifier(p.name) && + p.name.escapedText === "value" && + p.initializer && + getExpandoInitializer(p.initializer, isPrototypeAssignment); + }); + } + function getAssignedExpandoInitializer(node) { + if (node && node.parent && ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 62) { + var isPrototypeAssignment = isPrototypeAccess(node.parent.left); + return getExpandoInitializer(node.parent.right, isPrototypeAssignment) || + getDefaultedExpandoInitializer(node.parent.left, node.parent.right, isPrototypeAssignment); + } + if (node && ts.isCallExpression(node) && isBindableObjectDefinePropertyCall(node)) { + var result = hasExpandoValueProperty(node.arguments[2], node.arguments[1].text === "prototype"); + if (result) { + return result; + } + } + } + ts.getAssignedExpandoInitializer = getAssignedExpandoInitializer; + function getExpandoInitializer(initializer, isPrototypeAssignment) { + if (ts.isCallExpression(initializer)) { + var e = skipParentheses(initializer.expression); + return e.kind === 201 || e.kind === 202 ? initializer : undefined; + } + if (initializer.kind === 201 || + initializer.kind === 214 || + initializer.kind === 202) { + return initializer; + } + if (ts.isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) { + return initializer; + } + } + ts.getExpandoInitializer = getExpandoInitializer; + function getDefaultedExpandoInitializer(name, initializer, isPrototypeAssignment) { + var e = ts.isBinaryExpression(initializer) + && (initializer.operatorToken.kind === 56 || initializer.operatorToken.kind === 60) + && getExpandoInitializer(initializer.right, isPrototypeAssignment); + if (e && isSameEntityName(name, initializer.left)) { + return e; + } + } + function isDefaultedExpandoInitializer(node) { + var name = ts.isVariableDeclaration(node.parent) ? node.parent.name : + ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 62 ? node.parent.left : + undefined; + return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left); + } + ts.isDefaultedExpandoInitializer = isDefaultedExpandoInitializer; + function getNameOfExpando(node) { + if (ts.isBinaryExpression(node.parent)) { + var parent = ((node.parent.operatorToken.kind === 56 || node.parent.operatorToken.kind === 60) && ts.isBinaryExpression(node.parent.parent)) ? node.parent.parent : node.parent; + if (parent.operatorToken.kind === 62 && ts.isIdentifier(parent.left)) { + return parent.left; + } + } + else if (ts.isVariableDeclaration(node.parent)) { + return node.parent.name; + } + } + ts.getNameOfExpando = getNameOfExpando; + function isSameEntityName(name, initializer) { + if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) { + return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(name); + } + if (ts.isIdentifier(name) && isLiteralLikeAccess(initializer) && + (initializer.expression.kind === 104 || + ts.isIdentifier(initializer.expression) && + (initializer.expression.escapedText === "window" || + initializer.expression.escapedText === "self" || + initializer.expression.escapedText === "global"))) { + var nameOrArgument = getNameOrArgument(initializer); + if (ts.isPrivateIdentifier(nameOrArgument)) { + ts.Debug.fail("Unexpected PrivateIdentifier in name expression with literal-like access."); + } + return isSameEntityName(name, nameOrArgument); + } + if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) { + return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer) + && isSameEntityName(name.expression, initializer.expression); + } + return false; + } + function getRightMostAssignedExpression(node) { + while (isAssignmentExpression(node, true)) { + node = node.right; + } + return node; + } + ts.getRightMostAssignedExpression = getRightMostAssignedExpression; + function isExportsIdentifier(node) { + return ts.isIdentifier(node) && node.escapedText === "exports"; + } + ts.isExportsIdentifier = isExportsIdentifier; + function isModuleExportsAccessExpression(node) { + return (ts.isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node)) + && ts.isIdentifier(node.expression) + && node.expression.escapedText === "module" + && getElementOrPropertyAccessName(node) === "exports"; + } + ts.isModuleExportsAccessExpression = isModuleExportsAccessExpression; + function getAssignmentDeclarationKind(expr) { + var special = getAssignmentDeclarationKindWorker(expr); + return special === 5 || isInJSFile(expr) ? special : 0; + } + ts.getAssignmentDeclarationKind = getAssignmentDeclarationKind; + function isBindableObjectDefinePropertyCall(expr) { + return ts.length(expr.arguments) === 3 && + ts.isPropertyAccessExpression(expr.expression) && + ts.isIdentifier(expr.expression.expression) && + ts.idText(expr.expression.expression) === "Object" && + ts.idText(expr.expression.name) === "defineProperty" && + isStringOrNumericLiteralLike(expr.arguments[1]) && + isBindableStaticNameExpression(expr.arguments[0], true); + } + ts.isBindableObjectDefinePropertyCall = isBindableObjectDefinePropertyCall; + function isLiteralLikeAccess(node) { + return ts.isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node); + } + ts.isLiteralLikeAccess = isLiteralLikeAccess; + function isLiteralLikeElementAccess(node) { + return ts.isElementAccessExpression(node) && (isStringOrNumericLiteralLike(node.argumentExpression) || + isWellKnownSymbolSyntactically(node.argumentExpression)); + } + ts.isLiteralLikeElementAccess = isLiteralLikeElementAccess; + function isBindableStaticAccessExpression(node, excludeThisKeyword) { + return ts.isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 104 || isBindableStaticNameExpression(node.expression, true)) + || isBindableStaticElementAccessExpression(node, excludeThisKeyword); + } + ts.isBindableStaticAccessExpression = isBindableStaticAccessExpression; + function isBindableStaticElementAccessExpression(node, excludeThisKeyword) { + return isLiteralLikeElementAccess(node) + && ((!excludeThisKeyword && node.expression.kind === 104) || + isEntityNameExpression(node.expression) || + isBindableStaticAccessExpression(node.expression, true)); + } + ts.isBindableStaticElementAccessExpression = isBindableStaticElementAccessExpression; + function isBindableStaticNameExpression(node, excludeThisKeyword) { + return isEntityNameExpression(node) || isBindableStaticAccessExpression(node, excludeThisKeyword); + } + ts.isBindableStaticNameExpression = isBindableStaticNameExpression; + function getNameOrArgument(expr) { + if (ts.isPropertyAccessExpression(expr)) { + return expr.name; + } + return expr.argumentExpression; + } + ts.getNameOrArgument = getNameOrArgument; + function getAssignmentDeclarationKindWorker(expr) { + if (ts.isCallExpression(expr)) { + if (!isBindableObjectDefinePropertyCall(expr)) { + return 0; + } + var entityName = expr.arguments[0]; + if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) { + return 8; + } + if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") { + return 9; + } + return 7; + } + if (expr.operatorToken.kind !== 62 || !isAccessExpression(expr.left)) { + return 0; + } + if (isBindableStaticNameExpression(expr.left.expression, true) && getElementOrPropertyAccessName(expr.left) === "prototype" && ts.isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) { + return 6; + } + return getAssignmentDeclarationPropertyAccessKind(expr.left); + } + function getElementOrPropertyAccessArgumentExpressionOrName(node) { + if (ts.isPropertyAccessExpression(node)) { + return node.name; + } + var arg = skipParentheses(node.argumentExpression); + if (ts.isNumericLiteral(arg) || ts.isStringLiteralLike(arg)) { + return arg; + } + return node; + } + ts.getElementOrPropertyAccessArgumentExpressionOrName = getElementOrPropertyAccessArgumentExpressionOrName; + function getElementOrPropertyAccessName(node) { + var name = getElementOrPropertyAccessArgumentExpressionOrName(node); + if (name) { + if (ts.isIdentifier(name)) { + return name.escapedText; + } + if (ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) { + return ts.escapeLeadingUnderscores(name.text); + } + } + if (ts.isElementAccessExpression(node) && isWellKnownSymbolSyntactically(node.argumentExpression)) { + return getPropertyNameForKnownSymbolName(ts.idText(node.argumentExpression.name)); + } + return undefined; + } + ts.getElementOrPropertyAccessName = getElementOrPropertyAccessName; + function getAssignmentDeclarationPropertyAccessKind(lhs) { + if (lhs.expression.kind === 104) { + return 4; + } + else if (isModuleExportsAccessExpression(lhs)) { + return 2; + } + else if (isBindableStaticNameExpression(lhs.expression, true)) { + if (isPrototypeAccess(lhs.expression)) { + return 3; + } + var nextToLast = lhs; + while (!ts.isIdentifier(nextToLast.expression)) { + nextToLast = nextToLast.expression; + } + var id = nextToLast.expression; + if ((id.escapedText === "exports" || + id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") && + isBindableStaticAccessExpression(lhs)) { + return 1; + } + if (isBindableStaticNameExpression(lhs, true) || (ts.isElementAccessExpression(lhs) && isDynamicName(lhs) && lhs.expression.kind !== 104)) { + return 5; + } + } + return 0; + } + ts.getAssignmentDeclarationPropertyAccessKind = getAssignmentDeclarationPropertyAccessKind; + function getInitializerOfBinaryExpression(expr) { + while (ts.isBinaryExpression(expr.right)) { + expr = expr.right; + } + return expr.right; + } + ts.getInitializerOfBinaryExpression = getInitializerOfBinaryExpression; + function isPrototypePropertyAssignment(node) { + return ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 3; + } + ts.isPrototypePropertyAssignment = isPrototypePropertyAssignment; + function isSpecialPropertyDeclaration(expr) { + return isInJSFile(expr) && + expr.parent && expr.parent.kind === 226 && + (!ts.isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) && + !!ts.getJSDocTypeTag(expr.parent); + } + ts.isSpecialPropertyDeclaration = isSpecialPropertyDeclaration; + function isFunctionSymbol(symbol) { + if (!symbol || !symbol.valueDeclaration) { + return false; + } + var decl = symbol.valueDeclaration; + return decl.kind === 244 || ts.isVariableDeclaration(decl) && decl.initializer && ts.isFunctionLike(decl.initializer); + } + ts.isFunctionSymbol = isFunctionSymbol; + function importFromModuleSpecifier(node) { + return tryGetImportFromModuleSpecifier(node) || ts.Debug.failBadSyntaxKind(node.parent); + } + ts.importFromModuleSpecifier = importFromModuleSpecifier; + function tryGetImportFromModuleSpecifier(node) { + switch (node.parent.kind) { + case 254: + case 260: + return node.parent; + case 265: + return node.parent.parent; + case 196: + return isImportCall(node.parent) || isRequireCall(node.parent, false) ? node.parent : undefined; + case 187: + ts.Debug.assert(ts.isStringLiteral(node)); + return ts.tryCast(node.parent.parent, ts.isImportTypeNode); + default: + return undefined; + } + } + ts.tryGetImportFromModuleSpecifier = tryGetImportFromModuleSpecifier; + function getExternalModuleName(node) { + switch (node.kind) { + case 254: + case 260: + return node.moduleSpecifier; + case 253: + return node.moduleReference.kind === 265 ? node.moduleReference.expression : undefined; + case 188: + return isLiteralImportTypeNode(node) ? node.argument.literal : undefined; + default: + return ts.Debug.assertNever(node); + } + } + ts.getExternalModuleName = getExternalModuleName; + function getNamespaceDeclarationNode(node) { + switch (node.kind) { + case 254: + return node.importClause && ts.tryCast(node.importClause.namedBindings, ts.isNamespaceImport); + case 253: + return node; + case 260: + return node.exportClause && ts.tryCast(node.exportClause, ts.isNamespaceExport); + default: + return ts.Debug.assertNever(node); + } + } + ts.getNamespaceDeclarationNode = getNamespaceDeclarationNode; + function isDefaultImport(node) { + return node.kind === 254 && !!node.importClause && !!node.importClause.name; + } + ts.isDefaultImport = isDefaultImport; + function forEachImportClauseDeclaration(node, action) { + if (node.name) { + var result = action(node); + if (result) + return result; + } + if (node.namedBindings) { + var result = ts.isNamespaceImport(node.namedBindings) + ? action(node.namedBindings) + : ts.forEach(node.namedBindings.elements, action); + if (result) + return result; + } + } + ts.forEachImportClauseDeclaration = forEachImportClauseDeclaration; + function hasQuestionToken(node) { + if (node) { + switch (node.kind) { + case 156: + case 161: + case 160: + case 282: + case 281: + case 159: + case 158: + return node.questionToken !== undefined; + } + } + return false; + } + ts.hasQuestionToken = hasQuestionToken; + function isJSDocConstructSignature(node) { + var param = ts.isJSDocFunctionType(node) ? ts.firstOrUndefined(node.parameters) : undefined; + var name = ts.tryCast(param && param.name, ts.isIdentifier); + return !!name && name.escapedText === "new"; + } + ts.isJSDocConstructSignature = isJSDocConstructSignature; + function isJSDocTypeAlias(node) { + return node.kind === 321 || node.kind === 314 || node.kind === 315; + } + ts.isJSDocTypeAlias = isJSDocTypeAlias; + function isTypeAlias(node) { + return isJSDocTypeAlias(node) || ts.isTypeAliasDeclaration(node); + } + ts.isTypeAlias = isTypeAlias; + function getSourceOfAssignment(node) { + return ts.isExpressionStatement(node) && + ts.isBinaryExpression(node.expression) && + node.expression.operatorToken.kind === 62 + ? getRightMostAssignedExpression(node.expression) + : undefined; + } + function getSourceOfDefaultedAssignment(node) { + return ts.isExpressionStatement(node) && + ts.isBinaryExpression(node.expression) && + getAssignmentDeclarationKind(node.expression) !== 0 && + ts.isBinaryExpression(node.expression.right) && + (node.expression.right.operatorToken.kind === 56 || node.expression.right.operatorToken.kind === 60) + ? node.expression.right.right + : undefined; + } + function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) { + switch (node.kind) { + case 225: + var v = getSingleVariableOfVariableStatement(node); + return v && v.initializer; + case 159: + return node.initializer; + case 281: + return node.initializer; + } + } + ts.getSingleInitializerOfVariableStatementOrPropertyDeclaration = getSingleInitializerOfVariableStatementOrPropertyDeclaration; + function getSingleVariableOfVariableStatement(node) { + return ts.isVariableStatement(node) ? ts.firstOrUndefined(node.declarationList.declarations) : undefined; + } + function getNestedModuleDeclaration(node) { + return ts.isModuleDeclaration(node) && + node.body && + node.body.kind === 249 + ? node.body + : undefined; + } + function getJSDocCommentsAndTags(hostNode) { + var result; + if (isVariableLike(hostNode) && ts.hasInitializer(hostNode) && ts.hasJSDocNodes(hostNode.initializer)) { + result = ts.append(result, ts.last(hostNode.initializer.jsDoc)); + } + var node = hostNode; + while (node && node.parent) { + if (ts.hasJSDocNodes(node)) { + result = ts.append(result, ts.last(node.jsDoc)); + } + if (node.kind === 156) { + result = ts.addRange(result, ts.getJSDocParameterTags(node)); + break; + } + if (node.kind === 155) { + result = ts.addRange(result, ts.getJSDocTypeParameterTags(node)); + break; + } + node = getNextJSDocCommentLocation(node); + } + return result || ts.emptyArray; + } + ts.getJSDocCommentsAndTags = getJSDocCommentsAndTags; + function getNextJSDocCommentLocation(node) { + var parent = node.parent; + if (parent.kind === 281 || + parent.kind === 259 || + parent.kind === 159 || + parent.kind === 226 && node.kind === 194 || + getNestedModuleDeclaration(parent) || + ts.isBinaryExpression(node) && node.operatorToken.kind === 62) { + return parent; + } + else if (parent.parent && + (getSingleVariableOfVariableStatement(parent.parent) === node || + ts.isBinaryExpression(parent) && parent.operatorToken.kind === 62)) { + return parent.parent; + } + else if (parent.parent && parent.parent.parent && + (getSingleVariableOfVariableStatement(parent.parent.parent) || + getSingleInitializerOfVariableStatementOrPropertyDeclaration(parent.parent.parent) === node || + getSourceOfDefaultedAssignment(parent.parent.parent))) { + return parent.parent.parent; + } + } + function getParameterSymbolFromJSDoc(node) { + if (node.symbol) { + return node.symbol; + } + if (!ts.isIdentifier(node.name)) { + return undefined; + } + var name = node.name.escapedText; + var decl = getHostSignatureFromJSDoc(node); + if (!decl) { + return undefined; + } + var parameter = ts.find(decl.parameters, function (p) { return p.name.kind === 75 && p.name.escapedText === name; }); + return parameter && parameter.symbol; + } + ts.getParameterSymbolFromJSDoc = getParameterSymbolFromJSDoc; + function getHostSignatureFromJSDoc(node) { + return getHostSignatureFromJSDocHost(getJSDocHost(node)); + } + ts.getHostSignatureFromJSDoc = getHostSignatureFromJSDoc; + function getHostSignatureFromJSDocHost(host) { + var decl = getSourceOfDefaultedAssignment(host) || + getSourceOfAssignment(host) || + getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) || + getSingleVariableOfVariableStatement(host) || + getNestedModuleDeclaration(host) || + host; + return decl && ts.isFunctionLike(decl) ? decl : undefined; + } + ts.getHostSignatureFromJSDocHost = getHostSignatureFromJSDocHost; + function getJSDocHost(node) { + return ts.Debug.assertDefined(findAncestor(node.parent, ts.isJSDoc)).parent; + } + ts.getJSDocHost = getJSDocHost; + function getTypeParameterFromJsDoc(node) { + var name = node.name.escapedText; + var typeParameters = node.parent.parent.parent.typeParameters; + return typeParameters && ts.find(typeParameters, function (p) { return p.name.escapedText === name; }); + } + ts.getTypeParameterFromJsDoc = getTypeParameterFromJsDoc; + function hasRestParameter(s) { + var last = ts.lastOrUndefined(s.parameters); + return !!last && isRestParameter(last); + } + ts.hasRestParameter = hasRestParameter; + function isRestParameter(node) { + var type = ts.isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type; + return node.dotDotDotToken !== undefined || !!type && type.kind === 301; + } + ts.isRestParameter = isRestParameter; + function hasTypeArguments(node) { + return !!node.typeArguments; + } + ts.hasTypeArguments = hasTypeArguments; + function getAssignmentTargetKind(node) { + var parent = node.parent; + while (true) { + switch (parent.kind) { + case 209: + var binaryOperator = parent.operatorToken.kind; + return isAssignmentOperator(binaryOperator) && parent.left === node ? + binaryOperator === 62 ? 1 : 2 : + 0; + case 207: + case 208: + var unaryOperator = parent.operator; + return unaryOperator === 45 || unaryOperator === 46 ? 2 : 0; + case 231: + case 232: + return parent.initializer === node ? 1 : 0; + case 200: + case 192: + case 213: + case 218: + node = parent; + break; + case 282: + if (parent.name !== node) { + return 0; + } + node = parent.parent; + break; + case 281: + if (parent.name === node) { + return 0; + } + node = parent.parent; + break; + default: + return 0; + } + parent = node.parent; + } + } + ts.getAssignmentTargetKind = getAssignmentTargetKind; + function isAssignmentTarget(node) { + return getAssignmentTargetKind(node) !== 0; + } + ts.isAssignmentTarget = isAssignmentTarget; + function isNodeWithPossibleHoistedDeclaration(node) { + switch (node.kind) { + case 223: + case 225: + case 236: + case 227: + case 237: + case 251: + case 277: + case 278: + case 238: + case 230: + case 231: + case 232: + case 228: + case 229: + case 240: + case 280: + return true; + } + return false; + } + ts.isNodeWithPossibleHoistedDeclaration = isNodeWithPossibleHoistedDeclaration; + function isValueSignatureDeclaration(node) { + return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodOrAccessor(node) || ts.isFunctionDeclaration(node) || ts.isConstructorDeclaration(node); + } + ts.isValueSignatureDeclaration = isValueSignatureDeclaration; + function walkUp(node, kind) { + while (node && node.kind === kind) { + node = node.parent; + } + return node; + } + function walkUpParenthesizedTypes(node) { + return walkUp(node, 182); + } + ts.walkUpParenthesizedTypes = walkUpParenthesizedTypes; + function walkUpParenthesizedExpressions(node) { + return walkUp(node, 200); + } + ts.walkUpParenthesizedExpressions = walkUpParenthesizedExpressions; + function skipParentheses(node) { + while (node.kind === 200) { + node = node.expression; + } + return node; + } + ts.skipParentheses = skipParentheses; + function skipParenthesesUp(node) { + while (node.kind === 200) { + node = node.parent; + } + return node; + } + function isDeleteTarget(node) { + if (node.kind !== 194 && node.kind !== 195) { + return false; + } + node = walkUpParenthesizedExpressions(node.parent); + return node && node.kind === 203; + } + ts.isDeleteTarget = isDeleteTarget; + function isNodeDescendantOf(node, ancestor) { + while (node) { + if (node === ancestor) + return true; + node = node.parent; + } + return false; + } + ts.isNodeDescendantOf = isNodeDescendantOf; + function isDeclarationName(name) { + return !ts.isSourceFile(name) && !ts.isBindingPattern(name) && ts.isDeclaration(name.parent) && name.parent.name === name; + } + ts.isDeclarationName = isDeclarationName; + function getDeclarationFromName(name) { + var parent = name.parent; + switch (name.kind) { + case 10: + case 14: + case 8: + if (ts.isComputedPropertyName(parent)) + return parent.parent; + case 75: + if (ts.isDeclaration(parent)) { + return parent.name === name ? parent : undefined; + } + else if (ts.isQualifiedName(parent)) { + var tag = parent.parent; + return ts.isJSDocParameterTag(tag) && tag.name === parent ? tag : undefined; + } + else { + var binExp = parent.parent; + return ts.isBinaryExpression(binExp) && + getAssignmentDeclarationKind(binExp) !== 0 && + (binExp.left.symbol || binExp.symbol) && + ts.getNameOfDeclaration(binExp) === name + ? binExp + : undefined; + } + case 76: + return ts.isDeclaration(parent) && parent.name === name ? parent : undefined; + default: + return undefined; + } + } + ts.getDeclarationFromName = getDeclarationFromName; + function isLiteralComputedPropertyDeclarationName(node) { + return isStringOrNumericLiteralLike(node) && + node.parent.kind === 154 && + ts.isDeclaration(node.parent.parent); + } + ts.isLiteralComputedPropertyDeclarationName = isLiteralComputedPropertyDeclarationName; + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 159: + case 158: + case 161: + case 160: + case 163: + case 164: + case 284: + case 281: + case 194: + return parent.name === node; + case 153: + if (parent.right === node) { + while (parent.kind === 153) { + parent = parent.parent; + } + return parent.kind === 172 || parent.kind === 169; + } + return false; + case 191: + case 258: + return parent.propertyName === node; + case 263: + case 273: + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; + function isAliasSymbolDeclaration(node) { + return node.kind === 253 || + node.kind === 252 || + node.kind === 255 && !!node.name || + node.kind === 256 || + node.kind === 262 || + node.kind === 258 || + node.kind === 263 || + node.kind === 259 && exportAssignmentIsAlias(node) || + ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 && exportAssignmentIsAlias(node) || + ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62 && isAliasableExpression(node.parent.right) || + node.kind === 282 || + node.kind === 281 && isAliasableExpression(node.initializer); + } + ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; + function getAliasDeclarationFromName(node) { + switch (node.parent.kind) { + case 255: + case 258: + case 256: + case 263: + case 259: + case 253: + return node.parent; + case 153: + do { + node = node.parent; + } while (node.parent.kind === 153); + return getAliasDeclarationFromName(node); + } + } + ts.getAliasDeclarationFromName = getAliasDeclarationFromName; + function isAliasableExpression(e) { + return isEntityNameExpression(e) || ts.isClassExpression(e); + } + ts.isAliasableExpression = isAliasableExpression; + function exportAssignmentIsAlias(node) { + var e = getExportAssignmentExpression(node); + return isAliasableExpression(e); + } + ts.exportAssignmentIsAlias = exportAssignmentIsAlias; + function getExportAssignmentExpression(node) { + return ts.isExportAssignment(node) ? node.expression : node.right; + } + ts.getExportAssignmentExpression = getExportAssignmentExpression; + function getPropertyAssignmentAliasLikeExpression(node) { + return node.kind === 282 ? node.name : node.kind === 281 ? node.initializer : + node.parent.right; + } + ts.getPropertyAssignmentAliasLikeExpression = getPropertyAssignmentAliasLikeExpression; + function getEffectiveBaseTypeNode(node) { + var baseType = getClassExtendsHeritageElement(node); + if (baseType && isInJSFile(node)) { + var tag = ts.getJSDocAugmentsTag(node); + if (tag) { + return tag.class; + } + } + return baseType; + } + ts.getEffectiveBaseTypeNode = getEffectiveBaseTypeNode; + function getClassExtendsHeritageElement(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 90); + return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; + } + ts.getClassExtendsHeritageElement = getClassExtendsHeritageElement; + function getClassImplementsHeritageClauseElements(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 113); + return heritageClause ? heritageClause.types : undefined; + } + ts.getClassImplementsHeritageClauseElements = getClassImplementsHeritageClauseElements; + function getAllSuperTypeNodes(node) { + return ts.isInterfaceDeclaration(node) ? getInterfaceBaseTypeNodes(node) || ts.emptyArray : + ts.isClassLike(node) ? ts.concatenate(ts.singleElementArray(getEffectiveBaseTypeNode(node)), getClassImplementsHeritageClauseElements(node)) || ts.emptyArray : + ts.emptyArray; + } + ts.getAllSuperTypeNodes = getAllSuperTypeNodes; + function getInterfaceBaseTypeNodes(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 90); + return heritageClause ? heritageClause.types : undefined; + } + ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes; + function getHeritageClause(clauses, kind) { + if (clauses) { + for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) { + var clause = clauses_1[_i]; + if (clause.token === kind) { + return clause; + } + } + } + return undefined; + } + ts.getHeritageClause = getHeritageClause; + function getAncestor(node, kind) { + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; + } + return undefined; + } + ts.getAncestor = getAncestor; + function isKeyword(token) { + return 77 <= token && token <= 152; + } + ts.isKeyword = isKeyword; + function isContextualKeyword(token) { + return 122 <= token && token <= 152; + } + ts.isContextualKeyword = isContextualKeyword; + function isNonContextualKeyword(token) { + return isKeyword(token) && !isContextualKeyword(token); + } + ts.isNonContextualKeyword = isNonContextualKeyword; + function isFutureReservedKeyword(token) { + return 113 <= token && token <= 121; + } + ts.isFutureReservedKeyword = isFutureReservedKeyword; + function isStringANonContextualKeyword(name) { + var token = ts.stringToToken(name); + return token !== undefined && isNonContextualKeyword(token); + } + ts.isStringANonContextualKeyword = isStringANonContextualKeyword; + function isStringAKeyword(name) { + var token = ts.stringToToken(name); + return token !== undefined && isKeyword(token); + } + ts.isStringAKeyword = isStringAKeyword; + function isIdentifierANonContextualKeyword(_a) { + var originalKeywordKind = _a.originalKeywordKind; + return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind); + } + ts.isIdentifierANonContextualKeyword = isIdentifierANonContextualKeyword; + function isTrivia(token) { + return 2 <= token && token <= 7; + } + ts.isTrivia = isTrivia; + function getFunctionFlags(node) { + if (!node) { + return 4; + } + var flags = 0; + switch (node.kind) { + case 244: + case 201: + case 161: + if (node.asteriskToken) { + flags |= 1; + } + case 202: + if (hasModifier(node, 256)) { + flags |= 2; + } + break; + } + if (!node.body) { + flags |= 4; + } + return flags; + } + ts.getFunctionFlags = getFunctionFlags; + function isAsyncFunction(node) { + switch (node.kind) { + case 244: + case 201: + case 202: + case 161: + return node.body !== undefined + && node.asteriskToken === undefined + && hasModifier(node, 256); + } + return false; + } + ts.isAsyncFunction = isAsyncFunction; + function isStringOrNumericLiteralLike(node) { + return ts.isStringLiteralLike(node) || ts.isNumericLiteral(node); + } + ts.isStringOrNumericLiteralLike = isStringOrNumericLiteralLike; + function isSignedNumericLiteral(node) { + return ts.isPrefixUnaryExpression(node) && (node.operator === 39 || node.operator === 40) && ts.isNumericLiteral(node.operand); + } + ts.isSignedNumericLiteral = isSignedNumericLiteral; + function hasDynamicName(declaration) { + var name = ts.getNameOfDeclaration(declaration); + return !!name && isDynamicName(name); + } + ts.hasDynamicName = hasDynamicName; + function isDynamicName(name) { + if (!(name.kind === 154 || name.kind === 195)) { + return false; + } + var expr = ts.isElementAccessExpression(name) ? name.argumentExpression : name.expression; + return !isStringOrNumericLiteralLike(expr) && + !isSignedNumericLiteral(expr) && + !isWellKnownSymbolSyntactically(expr); + } + ts.isDynamicName = isDynamicName; + function isWellKnownSymbolSyntactically(node) { + return ts.isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression); + } + ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; + function getPropertyNameForPropertyNameNode(name) { + switch (name.kind) { + case 75: + case 76: + return name.escapedText; + case 10: + case 8: + return ts.escapeLeadingUnderscores(name.text); + case 154: + var nameExpression = name.expression; + if (isWellKnownSymbolSyntactically(nameExpression)) { + return getPropertyNameForKnownSymbolName(ts.idText(nameExpression.name)); + } + else if (isStringOrNumericLiteralLike(nameExpression)) { + return ts.escapeLeadingUnderscores(nameExpression.text); + } + return undefined; + default: + return ts.Debug.assertNever(name); + } + } + ts.getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode; + function isPropertyNameLiteral(node) { + switch (node.kind) { + case 75: + case 10: + case 14: + case 8: + return true; + default: + return false; + } + } + ts.isPropertyNameLiteral = isPropertyNameLiteral; + function getTextOfIdentifierOrLiteral(node) { + return ts.isIdentifierOrPrivateIdentifier(node) ? ts.idText(node) : node.text; + } + ts.getTextOfIdentifierOrLiteral = getTextOfIdentifierOrLiteral; + function getEscapedTextOfIdentifierOrLiteral(node) { + return ts.isIdentifierOrPrivateIdentifier(node) ? node.escapedText : ts.escapeLeadingUnderscores(node.text); + } + ts.getEscapedTextOfIdentifierOrLiteral = getEscapedTextOfIdentifierOrLiteral; + function getPropertyNameForUniqueESSymbol(symbol) { + return "__@" + ts.getSymbolId(symbol) + "@" + symbol.escapedName; + } + ts.getPropertyNameForUniqueESSymbol = getPropertyNameForUniqueESSymbol; + function getPropertyNameForKnownSymbolName(symbolName) { + return "__@" + symbolName; + } + ts.getPropertyNameForKnownSymbolName = getPropertyNameForKnownSymbolName; + function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) { + return "__#" + ts.getSymbolId(containingClassSymbol) + "@" + description; + } + ts.getSymbolNameForPrivateIdentifier = getSymbolNameForPrivateIdentifier; + function isKnownSymbol(symbol) { + return ts.startsWith(symbol.escapedName, "__@"); + } + ts.isKnownSymbol = isKnownSymbol; + function isESSymbolIdentifier(node) { + return node.kind === 75 && node.escapedText === "Symbol"; + } + ts.isESSymbolIdentifier = isESSymbolIdentifier; + function isPushOrUnshiftIdentifier(node) { + return node.escapedText === "push" || node.escapedText === "unshift"; + } + ts.isPushOrUnshiftIdentifier = isPushOrUnshiftIdentifier; + function isParameterDeclaration(node) { + var root = getRootDeclaration(node); + return root.kind === 156; + } + ts.isParameterDeclaration = isParameterDeclaration; + function getRootDeclaration(node) { + while (node.kind === 191) { + node = node.parent.parent; + } + return node; + } + ts.getRootDeclaration = getRootDeclaration; + function nodeStartsNewLexicalEnvironment(node) { + var kind = node.kind; + return kind === 162 + || kind === 201 + || kind === 244 + || kind === 202 + || kind === 161 + || kind === 163 + || kind === 164 + || kind === 249 + || kind === 290; + } + ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; + function nodeIsSynthesized(range) { + return positionIsSynthesized(range.pos) + || positionIsSynthesized(range.end); + } + ts.nodeIsSynthesized = nodeIsSynthesized; + function getOriginalSourceFile(sourceFile) { + return ts.getParseTreeNode(sourceFile, ts.isSourceFile) || sourceFile; + } + ts.getOriginalSourceFile = getOriginalSourceFile; + function getExpressionAssociativity(expression) { + var operator = getOperator(expression); + var hasArguments = expression.kind === 197 && expression.arguments !== undefined; + return getOperatorAssociativity(expression.kind, operator, hasArguments); + } + ts.getExpressionAssociativity = getExpressionAssociativity; + function getOperatorAssociativity(kind, operator, hasArguments) { + switch (kind) { + case 197: + return hasArguments ? 0 : 1; + case 207: + case 204: + case 205: + case 203: + case 206: + case 210: + case 212: + return 1; + case 209: + switch (operator) { + case 42: + case 62: + case 63: + case 64: + case 66: + case 65: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 74: + case 73: + return 1; + } + } + return 0; + } + ts.getOperatorAssociativity = getOperatorAssociativity; + function getExpressionPrecedence(expression) { + var operator = getOperator(expression); + var hasArguments = expression.kind === 197 && expression.arguments !== undefined; + return getOperatorPrecedence(expression.kind, operator, hasArguments); + } + ts.getExpressionPrecedence = getExpressionPrecedence; + function getOperator(expression) { + if (expression.kind === 209) { + return expression.operatorToken.kind; + } + else if (expression.kind === 207 || expression.kind === 208) { + return expression.operator; + } + else { + return expression.kind; + } + } + ts.getOperator = getOperator; + function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { + switch (nodeKind) { + case 326: + return 0; + case 213: + return 1; + case 212: + return 2; + case 210: + return 4; + case 209: + switch (operatorKind) { + case 27: + return 0; + case 62: + case 63: + case 64: + case 66: + case 65: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 74: + case 73: + return 3; + default: + return getBinaryOperatorPrecedence(operatorKind); + } + case 207: + case 204: + case 205: + case 203: + case 206: + return 16; + case 208: + return 17; + case 196: + return 18; + case 197: + return hasArguments ? 19 : 18; + case 198: + case 194: + case 195: + return 19; + case 104: + case 102: + case 75: + case 100: + case 106: + case 91: + case 8: + case 9: + case 10: + case 192: + case 193: + case 201: + case 202: + case 214: + case 266: + case 267: + case 270: + case 13: + case 14: + case 211: + case 200: + case 215: + return 20; + default: + return -1; + } + } + ts.getOperatorPrecedence = getOperatorPrecedence; + function getBinaryOperatorPrecedence(kind) { + switch (kind) { + case 60: + return 4; + case 56: + return 5; + case 55: + return 6; + case 51: + return 7; + case 52: + return 8; + case 50: + return 9; + case 34: + case 35: + case 36: + case 37: + return 10; + case 29: + case 31: + case 32: + case 33: + case 98: + case 97: + case 123: + return 11; + case 47: + case 48: + case 49: + return 12; + case 39: + case 40: + return 13; + case 41: + case 43: + case 44: + return 14; + case 42: + return 15; + } + return -1; + } + ts.getBinaryOperatorPrecedence = getBinaryOperatorPrecedence; + function createDiagnosticCollection() { + var nonFileDiagnostics = []; + var filesWithDiagnostics = []; + var fileDiagnostics = ts.createMap(); + var hasReadNonFileDiagnostics = false; + return { + add: add, + lookup: lookup, + getGlobalDiagnostics: getGlobalDiagnostics, + getDiagnostics: getDiagnostics, + reattachFileDiagnostics: reattachFileDiagnostics + }; + function reattachFileDiagnostics(newFile) { + ts.forEach(fileDiagnostics.get(newFile.fileName), function (diagnostic) { return diagnostic.file = newFile; }); + } + function lookup(diagnostic) { + var diagnostics; + if (diagnostic.file) { + diagnostics = fileDiagnostics.get(diagnostic.file.fileName); + } + else { + diagnostics = nonFileDiagnostics; + } + if (!diagnostics) { + return undefined; + } + var result = ts.binarySearch(diagnostics, diagnostic, ts.identity, compareDiagnosticsSkipRelatedInformation); + if (result >= 0) { + return diagnostics[result]; + } + return undefined; + } + function add(diagnostic) { + var diagnostics; + if (diagnostic.file) { + diagnostics = fileDiagnostics.get(diagnostic.file.fileName); + if (!diagnostics) { + diagnostics = []; + fileDiagnostics.set(diagnostic.file.fileName, diagnostics); + ts.insertSorted(filesWithDiagnostics, diagnostic.file.fileName, ts.compareStringsCaseSensitive); + } + } + else { + if (hasReadNonFileDiagnostics) { + hasReadNonFileDiagnostics = false; + nonFileDiagnostics = nonFileDiagnostics.slice(); + } + diagnostics = nonFileDiagnostics; + } + ts.insertSorted(diagnostics, diagnostic, compareDiagnostics); + } + function getGlobalDiagnostics() { + hasReadNonFileDiagnostics = true; + return nonFileDiagnostics; + } + function getDiagnostics(fileName) { + if (fileName) { + return fileDiagnostics.get(fileName) || []; + } + var fileDiags = ts.flatMapToMutable(filesWithDiagnostics, function (f) { return fileDiagnostics.get(f); }); + if (!nonFileDiagnostics.length) { + return fileDiags; + } + fileDiags.unshift.apply(fileDiags, nonFileDiagnostics); + return fileDiags; + } + } + ts.createDiagnosticCollection = createDiagnosticCollection; + var templateSubstitutionRegExp = /\$\{/g; + function escapeTemplateSubstitution(str) { + return str.replace(templateSubstitutionRegExp, "\\${"); + } + var doubleQuoteEscapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; + var singleQuoteEscapedCharsRegExp = /[\\\'\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; + var backtickQuoteEscapedCharsRegExp = /[\\\`]/g; + var escapedCharsMap = ts.createMapFromTemplate({ + "\t": "\\t", + "\v": "\\v", + "\f": "\\f", + "\b": "\\b", + "\r": "\\r", + "\n": "\\n", + "\\": "\\\\", + "\"": "\\\"", + "\'": "\\\'", + "\`": "\\\`", + "\u2028": "\\u2028", + "\u2029": "\\u2029", + "\u0085": "\\u0085" + }); + function encodeUtf16EscapeSequence(charCode) { + var hexCharCode = charCode.toString(16).toUpperCase(); + var paddedHexCode = ("0000" + hexCharCode).slice(-4); + return "\\u" + paddedHexCode; + } + function getReplacement(c, offset, input) { + if (c.charCodeAt(0) === 0) { + var lookAhead = input.charCodeAt(offset + c.length); + if (lookAhead >= 48 && lookAhead <= 57) { + return "\\x00"; + } + return "\\0"; + } + return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0)); + } + function escapeString(s, quoteChar) { + var escapedCharsRegExp = quoteChar === 96 ? backtickQuoteEscapedCharsRegExp : + quoteChar === 39 ? singleQuoteEscapedCharsRegExp : + doubleQuoteEscapedCharsRegExp; + return s.replace(escapedCharsRegExp, getReplacement); + } + ts.escapeString = escapeString; + var nonAsciiCharacters = /[^\u0000-\u007F]/g; + function escapeNonAsciiString(s, quoteChar) { + s = escapeString(s, quoteChar); + return nonAsciiCharacters.test(s) ? + s.replace(nonAsciiCharacters, function (c) { return encodeUtf16EscapeSequence(c.charCodeAt(0)); }) : + s; + } + ts.escapeNonAsciiString = escapeNonAsciiString; + var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g; + var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g; + var jsxEscapedCharsMap = ts.createMapFromTemplate({ + "\"": """, + "\'": "'" + }); + function encodeJsxCharacterEntity(charCode) { + var hexCharCode = charCode.toString(16).toUpperCase(); + return "&#x" + hexCharCode + ";"; + } + function getJsxAttributeStringReplacement(c) { + if (c.charCodeAt(0) === 0) { + return "�"; + } + return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0)); + } + function escapeJsxAttributeString(s, quoteChar) { + var escapedCharsRegExp = quoteChar === 39 ? jsxSingleQuoteEscapedCharsRegExp : + jsxDoubleQuoteEscapedCharsRegExp; + return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement); + } + ts.escapeJsxAttributeString = escapeJsxAttributeString; + function stripQuotes(name) { + var length = name.length; + if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) { + return name.substring(1, length - 1); + } + return name; + } + ts.stripQuotes = stripQuotes; + function isQuoteOrBacktick(charCode) { + return charCode === 39 || + charCode === 34 || + charCode === 96; + } + function isIntrinsicJsxName(name) { + var ch = name.charCodeAt(0); + return (ch >= 97 && ch <= 122) || ts.stringContains(name, "-"); + } + ts.isIntrinsicJsxName = isIntrinsicJsxName; + var indentStrings = ["", " "]; + function getIndentString(level) { + if (indentStrings[level] === undefined) { + indentStrings[level] = getIndentString(level - 1) + indentStrings[1]; + } + return indentStrings[level]; + } + ts.getIndentString = getIndentString; + function getIndentSize() { + return indentStrings[1].length; + } + ts.getIndentSize = getIndentSize; + function createTextWriter(newLine) { + var output; + var indent; + var lineStart; + var lineCount; + var linePos; + var hasTrailingComment = false; + function updateLineCountAndPosFor(s) { + var lineStartsOfS = ts.computeLineStarts(s); + if (lineStartsOfS.length > 1) { + lineCount = lineCount + lineStartsOfS.length - 1; + linePos = output.length - s.length + ts.last(lineStartsOfS); + lineStart = (linePos - output.length) === 0; + } + else { + lineStart = false; + } + } + function writeText(s) { + if (s && s.length) { + if (lineStart) { + s = getIndentString(indent) + s; + lineStart = false; + } + output += s; + updateLineCountAndPosFor(s); + } + } + function write(s) { + if (s) + hasTrailingComment = false; + writeText(s); + } + function writeComment(s) { + if (s) + hasTrailingComment = true; + writeText(s); + } + function reset() { + output = ""; + indent = 0; + lineStart = true; + lineCount = 0; + linePos = 0; + hasTrailingComment = false; + } + function rawWrite(s) { + if (s !== undefined) { + output += s; + updateLineCountAndPosFor(s); + hasTrailingComment = false; + } + } + function writeLiteral(s) { + if (s && s.length) { + write(s); + } + } + function writeLine() { + if (!lineStart) { + output += newLine; + lineCount++; + linePos = output.length; + lineStart = true; + hasTrailingComment = false; + } + } + function getTextPosWithWriteLine() { + return lineStart ? output.length : (output.length + newLine.length); + } + reset(); + return { + write: write, + rawWrite: rawWrite, + writeLiteral: writeLiteral, + writeLine: writeLine, + increaseIndent: function () { indent++; }, + decreaseIndent: function () { indent--; }, + getIndent: function () { return indent; }, + getTextPos: function () { return output.length; }, + getLine: function () { return lineCount; }, + getColumn: function () { return lineStart ? indent * getIndentSize() : output.length - linePos; }, + getText: function () { return output; }, + isAtStartOfLine: function () { return lineStart; }, + hasTrailingComment: function () { return hasTrailingComment; }, + hasTrailingWhitespace: function () { return !!output.length && ts.isWhiteSpaceLike(output.charCodeAt(output.length - 1)); }, + clear: reset, + reportInaccessibleThisError: ts.noop, + reportPrivateInBaseOfClassExpression: ts.noop, + reportInaccessibleUniqueSymbolError: ts.noop, + trackSymbol: ts.noop, + writeKeyword: write, + writeOperator: write, + writeParameter: write, + writeProperty: write, + writePunctuation: write, + writeSpace: write, + writeStringLiteral: write, + writeSymbol: function (s, _) { return write(s); }, + writeTrailingSemicolon: write, + writeComment: writeComment, + getTextPosWithWriteLine: getTextPosWithWriteLine + }; + } + ts.createTextWriter = createTextWriter; + function getTrailingSemicolonDeferringWriter(writer) { + var pendingTrailingSemicolon = false; + function commitPendingTrailingSemicolon() { + if (pendingTrailingSemicolon) { + writer.writeTrailingSemicolon(";"); + pendingTrailingSemicolon = false; + } + } + return __assign(__assign({}, writer), { writeTrailingSemicolon: function () { + pendingTrailingSemicolon = true; + }, + writeLiteral: function (s) { + commitPendingTrailingSemicolon(); + writer.writeLiteral(s); + }, + writeStringLiteral: function (s) { + commitPendingTrailingSemicolon(); + writer.writeStringLiteral(s); + }, + writeSymbol: function (s, sym) { + commitPendingTrailingSemicolon(); + writer.writeSymbol(s, sym); + }, + writePunctuation: function (s) { + commitPendingTrailingSemicolon(); + writer.writePunctuation(s); + }, + writeKeyword: function (s) { + commitPendingTrailingSemicolon(); + writer.writeKeyword(s); + }, + writeOperator: function (s) { + commitPendingTrailingSemicolon(); + writer.writeOperator(s); + }, + writeParameter: function (s) { + commitPendingTrailingSemicolon(); + writer.writeParameter(s); + }, + writeSpace: function (s) { + commitPendingTrailingSemicolon(); + writer.writeSpace(s); + }, + writeProperty: function (s) { + commitPendingTrailingSemicolon(); + writer.writeProperty(s); + }, + writeComment: function (s) { + commitPendingTrailingSemicolon(); + writer.writeComment(s); + }, + writeLine: function () { + commitPendingTrailingSemicolon(); + writer.writeLine(); + }, + increaseIndent: function () { + commitPendingTrailingSemicolon(); + writer.increaseIndent(); + }, + decreaseIndent: function () { + commitPendingTrailingSemicolon(); + writer.decreaseIndent(); + } }); + } + ts.getTrailingSemicolonDeferringWriter = getTrailingSemicolonDeferringWriter; + function getResolvedExternalModuleName(host, file, referenceFile) { + return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName); + } + ts.getResolvedExternalModuleName = getResolvedExternalModuleName; + function getExternalModuleNameFromDeclaration(host, resolver, declaration) { + var file = resolver.getExternalModuleFileFromDeclaration(declaration); + if (!file || file.isDeclarationFile) { + return undefined; + } + return getResolvedExternalModuleName(host, file); + } + ts.getExternalModuleNameFromDeclaration = getExternalModuleNameFromDeclaration; + function getExternalModuleNameFromPath(host, fileName, referencePath) { + var getCanonicalFileName = function (f) { return host.getCanonicalFileName(f); }; + var dir = ts.toPath(referencePath ? ts.getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName); + var filePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); + var relativePath = ts.getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, false); + var extensionless = removeFileExtension(relativePath); + return referencePath ? ts.ensurePathIsNonModuleName(extensionless) : extensionless; + } + ts.getExternalModuleNameFromPath = getExternalModuleNameFromPath; + function getOwnEmitOutputFilePath(fileName, host, extension) { + var compilerOptions = host.getCompilerOptions(); + var emitOutputFilePathWithoutExtension; + if (compilerOptions.outDir) { + emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(fileName, host, compilerOptions.outDir)); + } + else { + emitOutputFilePathWithoutExtension = removeFileExtension(fileName); + } + return emitOutputFilePathWithoutExtension + extension; + } + ts.getOwnEmitOutputFilePath = getOwnEmitOutputFilePath; + function getDeclarationEmitOutputFilePath(fileName, host) { + return getDeclarationEmitOutputFilePathWorker(fileName, host.getCompilerOptions(), host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); + } + ts.getDeclarationEmitOutputFilePath = getDeclarationEmitOutputFilePath; + function getDeclarationEmitOutputFilePathWorker(fileName, options, currentDirectory, commonSourceDirectory, getCanonicalFileName) { + var outputDir = options.declarationDir || options.outDir; + var path = outputDir + ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName) + : fileName; + return removeFileExtension(path) + ".d.ts"; + } + ts.getDeclarationEmitOutputFilePathWorker = getDeclarationEmitOutputFilePathWorker; + function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) { + var options = host.getCompilerOptions(); + if (options.outFile || options.out) { + var moduleKind = getEmitModuleKind(options); + var moduleEmitEnabled_1 = options.emitDeclarationOnly || moduleKind === ts.ModuleKind.AMD || moduleKind === ts.ModuleKind.System; + return ts.filter(host.getSourceFiles(), function (sourceFile) { + return (moduleEmitEnabled_1 || !ts.isExternalModule(sourceFile)) && + sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); + }); + } + else { + var sourceFiles = targetSourceFile === undefined ? host.getSourceFiles() : [targetSourceFile]; + return ts.filter(sourceFiles, function (sourceFile) { return sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); }); + } + } + ts.getSourceFilesToEmit = getSourceFilesToEmit; + function sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit) { + var options = host.getCompilerOptions(); + return !(options.noEmitForJsFiles && isSourceFileJS(sourceFile)) && + !sourceFile.isDeclarationFile && + !host.isSourceFileFromExternalLibrary(sourceFile) && + !(isJsonSourceFile(sourceFile) && host.getResolvedProjectReferenceToRedirect(sourceFile.fileName)) && + (forceDtsEmit || !host.isSourceOfProjectReferenceRedirect(sourceFile.fileName)); + } + ts.sourceFileMayBeEmitted = sourceFileMayBeEmitted; + function getSourceFilePathInNewDir(fileName, host, newDirPath) { + return getSourceFilePathInNewDirWorker(fileName, newDirPath, host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); + } + ts.getSourceFilePathInNewDir = getSourceFilePathInNewDir; + function getSourceFilePathInNewDirWorker(fileName, newDirPath, currentDirectory, commonSourceDirectory, getCanonicalFileName) { + var sourceFilePath = ts.getNormalizedAbsolutePath(fileName, currentDirectory); + var isSourceFileInCommonSourceDirectory = getCanonicalFileName(sourceFilePath).indexOf(getCanonicalFileName(commonSourceDirectory)) === 0; + sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath; + return ts.combinePaths(newDirPath, sourceFilePath); + } + ts.getSourceFilePathInNewDirWorker = getSourceFilePathInNewDirWorker; + function writeFile(host, diagnostics, fileName, data, writeByteOrderMark, sourceFiles) { + host.writeFile(fileName, data, writeByteOrderMark, function (hostErrorMessage) { + diagnostics.add(createCompilerDiagnostic(ts.Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage)); + }, sourceFiles); + } + ts.writeFile = writeFile; + function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) { + if (directoryPath.length > ts.getRootLength(directoryPath) && !directoryExists(directoryPath)) { + var parentDirectory = ts.getDirectoryPath(directoryPath); + ensureDirectoriesExist(parentDirectory, createDirectory, directoryExists); + createDirectory(directoryPath); + } + } + function writeFileEnsuringDirectories(path, data, writeByteOrderMark, writeFile, createDirectory, directoryExists) { + try { + writeFile(path, data, writeByteOrderMark); + } + catch (_a) { + ensureDirectoriesExist(ts.getDirectoryPath(ts.normalizePath(path)), createDirectory, directoryExists); + writeFile(path, data, writeByteOrderMark); + } + } + ts.writeFileEnsuringDirectories = writeFileEnsuringDirectories; + function getLineOfLocalPosition(currentSourceFile, pos) { + return ts.getLineAndCharacterOfPosition(currentSourceFile, pos).line; + } + ts.getLineOfLocalPosition = getLineOfLocalPosition; + function getLineOfLocalPositionFromLineMap(lineMap, pos) { + return ts.computeLineAndCharacterOfPosition(lineMap, pos).line; + } + ts.getLineOfLocalPositionFromLineMap = getLineOfLocalPositionFromLineMap; + function getFirstConstructorWithBody(node) { + return ts.find(node.members, function (member) { return ts.isConstructorDeclaration(member) && nodeIsPresent(member.body); }); + } + ts.getFirstConstructorWithBody = getFirstConstructorWithBody; + function getSetAccessorValueParameter(accessor) { + if (accessor && accessor.parameters.length > 0) { + var hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]); + return accessor.parameters[hasThis ? 1 : 0]; + } + } + ts.getSetAccessorValueParameter = getSetAccessorValueParameter; + function getSetAccessorTypeAnnotationNode(accessor) { + var parameter = getSetAccessorValueParameter(accessor); + return parameter && parameter.type; + } + ts.getSetAccessorTypeAnnotationNode = getSetAccessorTypeAnnotationNode; + function getThisParameter(signature) { + if (signature.parameters.length && !ts.isJSDocSignature(signature)) { + var thisParameter = signature.parameters[0]; + if (parameterIsThisKeyword(thisParameter)) { + return thisParameter; + } + } + } + ts.getThisParameter = getThisParameter; + function parameterIsThisKeyword(parameter) { + return isThisIdentifier(parameter.name); + } + ts.parameterIsThisKeyword = parameterIsThisKeyword; + function isThisIdentifier(node) { + return !!node && node.kind === 75 && identifierIsThisKeyword(node); + } + ts.isThisIdentifier = isThisIdentifier; + function identifierIsThisKeyword(id) { + return id.originalKeywordKind === 104; + } + ts.identifierIsThisKeyword = identifierIsThisKeyword; + function getAllAccessorDeclarations(declarations, accessor) { + var firstAccessor; + var secondAccessor; + var getAccessor; + var setAccessor; + if (hasDynamicName(accessor)) { + firstAccessor = accessor; + if (accessor.kind === 163) { + getAccessor = accessor; + } + else if (accessor.kind === 164) { + setAccessor = accessor; + } + else { + ts.Debug.fail("Accessor has wrong kind"); + } + } + else { + ts.forEach(declarations, function (member) { + if (ts.isAccessor(member) + && hasModifier(member, 32) === hasModifier(accessor, 32)) { + var memberName = getPropertyNameForPropertyNameNode(member.name); + var accessorName = getPropertyNameForPropertyNameNode(accessor.name); + if (memberName === accessorName) { + if (!firstAccessor) { + firstAccessor = member; + } + else if (!secondAccessor) { + secondAccessor = member; + } + if (member.kind === 163 && !getAccessor) { + getAccessor = member; + } + if (member.kind === 164 && !setAccessor) { + setAccessor = member; + } + } + } + }); + } + return { + firstAccessor: firstAccessor, + secondAccessor: secondAccessor, + getAccessor: getAccessor, + setAccessor: setAccessor + }; + } + ts.getAllAccessorDeclarations = getAllAccessorDeclarations; + function getEffectiveTypeAnnotationNode(node) { + if (!isInJSFile(node) && ts.isFunctionDeclaration(node)) + return undefined; + var type = node.type; + if (type || !isInJSFile(node)) + return type; + return ts.isJSDocPropertyLikeTag(node) ? node.typeExpression && node.typeExpression.type : ts.getJSDocType(node); + } + ts.getEffectiveTypeAnnotationNode = getEffectiveTypeAnnotationNode; + function getTypeAnnotationNode(node) { + return node.type; + } + ts.getTypeAnnotationNode = getTypeAnnotationNode; + function getEffectiveReturnTypeNode(node) { + return ts.isJSDocSignature(node) ? + node.type && node.type.typeExpression && node.type.typeExpression.type : + node.type || (isInJSFile(node) ? ts.getJSDocReturnType(node) : undefined); + } + ts.getEffectiveReturnTypeNode = getEffectiveReturnTypeNode; + function getJSDocTypeParameterDeclarations(node) { + return ts.flatMap(ts.getJSDocTags(node), function (tag) { return isNonTypeAliasTemplate(tag) ? tag.typeParameters : undefined; }); + } + ts.getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations; + function isNonTypeAliasTemplate(tag) { + return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 303 && tag.parent.tags.some(isJSDocTypeAlias)); + } + function getEffectiveSetAccessorTypeAnnotationNode(node) { + var parameter = getSetAccessorValueParameter(node); + return parameter && getEffectiveTypeAnnotationNode(parameter); + } + ts.getEffectiveSetAccessorTypeAnnotationNode = getEffectiveSetAccessorTypeAnnotationNode; + function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) { + emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments); + } + ts.emitNewLineBeforeLeadingComments = emitNewLineBeforeLeadingComments; + function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) { + if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos && + getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) { + writer.writeLine(); + } + } + ts.emitNewLineBeforeLeadingCommentsOfPosition = emitNewLineBeforeLeadingCommentsOfPosition; + function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) { + if (pos !== commentPos && + getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) { + writer.writeLine(); + } + } + ts.emitNewLineBeforeLeadingCommentOfPosition = emitNewLineBeforeLeadingCommentOfPosition; + function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) { + if (comments && comments.length > 0) { + if (leadingSeparator) { + writer.writeSpace(" "); + } + var emitInterveningSeparator = false; + for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) { + var comment = comments_1[_i]; + if (emitInterveningSeparator) { + writer.writeSpace(" "); + emitInterveningSeparator = false; + } + writeComment(text, lineMap, writer, comment.pos, comment.end, newLine); + if (comment.hasTrailingNewLine) { + writer.writeLine(); + } + else { + emitInterveningSeparator = true; + } + } + if (emitInterveningSeparator && trailingSeparator) { + writer.writeSpace(" "); + } + } + } + ts.emitComments = emitComments; + function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) { + var leadingComments; + var currentDetachedCommentInfo; + if (removeComments) { + if (node.pos === 0) { + leadingComments = ts.filter(ts.getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal); + } + } + else { + leadingComments = ts.getLeadingCommentRanges(text, node.pos); + } + if (leadingComments) { + var detachedComments = []; + var lastComment = void 0; + for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) { + var comment = leadingComments_1[_i]; + if (lastComment) { + var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end); + var commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos); + if (commentLine >= lastCommentLine + 2) { + break; + } + } + detachedComments.push(comment); + lastComment = comment; + } + if (detachedComments.length) { + var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, ts.last(detachedComments).end); + var nodeLine = getLineOfLocalPositionFromLineMap(lineMap, ts.skipTrivia(text, node.pos)); + if (nodeLine >= lastCommentLine + 2) { + emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments); + emitComments(text, lineMap, writer, detachedComments, false, true, newLine, writeComment); + currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.last(detachedComments).end }; + } + } + } + return currentDetachedCommentInfo; + function isPinnedCommentLocal(comment) { + return isPinnedComment(text, comment.pos); + } + } + ts.emitDetachedComments = emitDetachedComments; + function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) { + if (text.charCodeAt(commentPos + 1) === 42) { + var firstCommentLineAndCharacter = ts.computeLineAndCharacterOfPosition(lineMap, commentPos); + var lineCount = lineMap.length; + var firstCommentLineIndent = void 0; + for (var pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) { + var nextLineStart = (currentLine + 1) === lineCount + ? text.length + 1 + : lineMap[currentLine + 1]; + if (pos !== commentPos) { + if (firstCommentLineIndent === undefined) { + firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos); + } + var currentWriterIndentSpacing = writer.getIndent() * getIndentSize(); + var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart); + if (spacesToEmit > 0) { + var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize(); + var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize()); + writer.rawWrite(indentSizeSpaceString); + while (numberOfSingleSpacesToEmit) { + writer.rawWrite(" "); + numberOfSingleSpacesToEmit--; + } + } + else { + writer.rawWrite(""); + } + } + writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart); + pos = nextLineStart; + } + } + else { + writer.writeComment(text.substring(commentPos, commentEnd)); + } + } + ts.writeCommentRange = writeCommentRange; + function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) { + var end = Math.min(commentEnd, nextLineStart - 1); + var currentLineText = text.substring(pos, end).replace(/^\s+|\s+$/g, ""); + if (currentLineText) { + writer.writeComment(currentLineText); + if (end !== commentEnd) { + writer.writeLine(); + } + } + else { + writer.rawWrite(newLine); + } + } + function calculateIndent(text, pos, end) { + var currentLineIndent = 0; + for (; pos < end && ts.isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) { + if (text.charCodeAt(pos) === 9) { + currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize()); + } + else { + currentLineIndent++; + } + } + return currentLineIndent; + } + function hasModifiers(node) { + return getModifierFlags(node) !== 0; + } + ts.hasModifiers = hasModifiers; + function hasModifier(node, flags) { + return !!getSelectedModifierFlags(node, flags); + } + ts.hasModifier = hasModifier; + function hasStaticModifier(node) { + return hasModifier(node, 32); + } + ts.hasStaticModifier = hasStaticModifier; + function hasReadonlyModifier(node) { + return hasModifier(node, 64); + } + ts.hasReadonlyModifier = hasReadonlyModifier; + function getSelectedModifierFlags(node, flags) { + return getModifierFlags(node) & flags; + } + ts.getSelectedModifierFlags = getSelectedModifierFlags; + function getModifierFlags(node) { + if (node.modifierFlagsCache & 536870912) { + return node.modifierFlagsCache & ~536870912; + } + var flags = getModifierFlagsNoCache(node); + node.modifierFlagsCache = flags | 536870912; + return flags; + } + ts.getModifierFlags = getModifierFlags; + function getModifierFlagsNoCache(node) { + var flags = 0; + if (node.modifiers) { + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var modifier = _a[_i]; + flags |= modifierToFlag(modifier.kind); + } + } + if (isInJSFile(node) && !!node.parent) { + var tags = (ts.getJSDocPublicTag(node) ? 4 : 0) + | (ts.getJSDocPrivateTag(node) ? 8 : 0) + | (ts.getJSDocProtectedTag(node) ? 16 : 0) + | (ts.getJSDocReadonlyTag(node) ? 64 : 0); + flags |= tags; + } + if (node.flags & 4 || (node.kind === 75 && node.isInJSDocNamespace)) { + flags |= 1; + } + return flags; + } + ts.getModifierFlagsNoCache = getModifierFlagsNoCache; + function modifierToFlag(token) { + switch (token) { + case 120: return 32; + case 119: return 4; + case 118: return 16; + case 117: return 8; + case 122: return 128; + case 89: return 1; + case 130: return 2; + case 81: return 2048; + case 84: return 512; + case 126: return 256; + case 138: return 64; + } + return 0; + } + ts.modifierToFlag = modifierToFlag; + function isLogicalOperator(token) { + return token === 56 + || token === 55 + || token === 53; + } + ts.isLogicalOperator = isLogicalOperator; + function isAssignmentOperator(token) { + return token >= 62 && token <= 74; + } + ts.isAssignmentOperator = isAssignmentOperator; + function tryGetClassExtendingExpressionWithTypeArguments(node) { + var cls = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node); + return cls && !cls.isImplements ? cls.class : undefined; + } + ts.tryGetClassExtendingExpressionWithTypeArguments = tryGetClassExtendingExpressionWithTypeArguments; + function tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node) { + return ts.isExpressionWithTypeArguments(node) + && ts.isHeritageClause(node.parent) + && ts.isClassLike(node.parent.parent) + ? { class: node.parent.parent, isImplements: node.parent.token === 113 } + : undefined; + } + ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments = tryGetClassImplementingOrExtendingExpressionWithTypeArguments; + function isAssignmentExpression(node, excludeCompoundAssignment) { + return ts.isBinaryExpression(node) + && (excludeCompoundAssignment + ? node.operatorToken.kind === 62 + : isAssignmentOperator(node.operatorToken.kind)) + && ts.isLeftHandSideExpression(node.left); + } + ts.isAssignmentExpression = isAssignmentExpression; + function isDestructuringAssignment(node) { + if (isAssignmentExpression(node, true)) { + var kind = node.left.kind; + return kind === 193 + || kind === 192; + } + return false; + } + ts.isDestructuringAssignment = isDestructuringAssignment; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return tryGetClassExtendingExpressionWithTypeArguments(node) !== undefined; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; + function isEntityNameExpression(node) { + return node.kind === 75 || isPropertyAccessEntityNameExpression(node); + } + ts.isEntityNameExpression = isEntityNameExpression; + function getFirstIdentifier(node) { + switch (node.kind) { + case 75: + return node; + case 153: + do { + node = node.left; + } while (node.kind !== 75); + return node; + case 194: + do { + node = node.expression; + } while (node.kind !== 75); + return node; + } + } + ts.getFirstIdentifier = getFirstIdentifier; + function isDottedName(node) { + return node.kind === 75 || node.kind === 104 || node.kind === 102 || + node.kind === 194 && isDottedName(node.expression) || + node.kind === 200 && isDottedName(node.expression); + } + ts.isDottedName = isDottedName; + function isPropertyAccessEntityNameExpression(node) { + return ts.isPropertyAccessExpression(node) && isEntityNameExpression(node.expression); + } + ts.isPropertyAccessEntityNameExpression = isPropertyAccessEntityNameExpression; + function tryGetPropertyAccessOrIdentifierToString(expr) { + if (ts.isPropertyAccessExpression(expr)) { + var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (baseStr !== undefined) { + return baseStr + "." + expr.name; + } + } + else if (ts.isIdentifier(expr)) { + return ts.unescapeLeadingUnderscores(expr.escapedText); + } + return undefined; + } + ts.tryGetPropertyAccessOrIdentifierToString = tryGetPropertyAccessOrIdentifierToString; + function isPrototypeAccess(node) { + return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype"; + } + ts.isPrototypeAccess = isPrototypeAccess; + function isRightSideOfQualifiedNameOrPropertyAccess(node) { + return (node.parent.kind === 153 && node.parent.right === node) || + (node.parent.kind === 194 && node.parent.name === node); + } + ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; + function isEmptyObjectLiteral(expression) { + return expression.kind === 193 && + expression.properties.length === 0; + } + ts.isEmptyObjectLiteral = isEmptyObjectLiteral; + function isEmptyArrayLiteral(expression) { + return expression.kind === 192 && + expression.elements.length === 0; + } + ts.isEmptyArrayLiteral = isEmptyArrayLiteral; + function getLocalSymbolForExportDefault(symbol) { + return isExportDefaultSymbol(symbol) ? symbol.declarations[0].localSymbol : undefined; + } + ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault; + function isExportDefaultSymbol(symbol) { + return symbol && ts.length(symbol.declarations) > 0 && hasModifier(symbol.declarations[0], 512); + } + function tryExtractTSExtension(fileName) { + return ts.find(ts.supportedTSExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.tryExtractTSExtension = tryExtractTSExtension; + function getExpandedCharCodes(input) { + var output = []; + var length = input.length; + for (var i = 0; i < length; i++) { + var charCode = input.charCodeAt(i); + if (charCode < 0x80) { + output.push(charCode); + } + else if (charCode < 0x800) { + output.push((charCode >> 6) | 192); + output.push((charCode & 63) | 128); + } + else if (charCode < 0x10000) { + output.push((charCode >> 12) | 224); + output.push(((charCode >> 6) & 63) | 128); + output.push((charCode & 63) | 128); + } + else if (charCode < 0x20000) { + output.push((charCode >> 18) | 240); + output.push(((charCode >> 12) & 63) | 128); + output.push(((charCode >> 6) & 63) | 128); + output.push((charCode & 63) | 128); + } + else { + ts.Debug.assert(false, "Unexpected code point"); + } + } + return output; + } + var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + function convertToBase64(input) { + var result = ""; + var charCodes = getExpandedCharCodes(input); + var i = 0; + var length = charCodes.length; + var byte1, byte2, byte3, byte4; + while (i < length) { + byte1 = charCodes[i] >> 2; + byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4; + byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6; + byte4 = charCodes[i + 2] & 63; + if (i + 1 >= length) { + byte3 = byte4 = 64; + } + else if (i + 2 >= length) { + byte4 = 64; + } + result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4); + i += 3; + } + return result; + } + ts.convertToBase64 = convertToBase64; + function getStringFromExpandedCharCodes(codes) { + var output = ""; + var i = 0; + var length = codes.length; + while (i < length) { + var charCode = codes[i]; + if (charCode < 0x80) { + output += String.fromCharCode(charCode); + i++; + } + else if ((charCode & 192) === 192) { + var value = charCode & 63; + i++; + var nextCode = codes[i]; + while ((nextCode & 192) === 128) { + value = (value << 6) | (nextCode & 63); + i++; + nextCode = codes[i]; + } + output += String.fromCharCode(value); + } + else { + output += String.fromCharCode(charCode); + i++; + } + } + return output; + } + function base64encode(host, input) { + if (host && host.base64encode) { + return host.base64encode(input); + } + return convertToBase64(input); + } + ts.base64encode = base64encode; + function base64decode(host, input) { + if (host && host.base64decode) { + return host.base64decode(input); + } + var length = input.length; + var expandedCharCodes = []; + var i = 0; + while (i < length) { + if (input.charCodeAt(i) === base64Digits.charCodeAt(64)) { + break; + } + var ch1 = base64Digits.indexOf(input[i]); + var ch2 = base64Digits.indexOf(input[i + 1]); + var ch3 = base64Digits.indexOf(input[i + 2]); + var ch4 = base64Digits.indexOf(input[i + 3]); + var code1 = ((ch1 & 63) << 2) | ((ch2 >> 4) & 3); + var code2 = ((ch2 & 15) << 4) | ((ch3 >> 2) & 15); + var code3 = ((ch3 & 3) << 6) | (ch4 & 63); + if (code2 === 0 && ch3 !== 0) { + expandedCharCodes.push(code1); + } + else if (code3 === 0 && ch4 !== 0) { + expandedCharCodes.push(code1, code2); + } + else { + expandedCharCodes.push(code1, code2, code3); + } + i += 4; + } + return getStringFromExpandedCharCodes(expandedCharCodes); + } + ts.base64decode = base64decode; + function readJson(path, host) { + try { + var jsonText = host.readFile(path); + if (!jsonText) + return {}; + var result = ts.parseConfigFileTextToJson(path, jsonText); + if (result.error) { + return {}; + } + return result.config; + } + catch (e) { + return {}; + } + } + ts.readJson = readJson; + function directoryProbablyExists(directoryName, host) { + return !host.directoryExists || host.directoryExists(directoryName); + } + ts.directoryProbablyExists = directoryProbablyExists; + var carriageReturnLineFeed = "\r\n"; + var lineFeed = "\n"; + function getNewLineCharacter(options, getNewLine) { + switch (options.newLine) { + case 0: + return carriageReturnLineFeed; + case 1: + return lineFeed; + } + return getNewLine ? getNewLine() : ts.sys ? ts.sys.newLine : carriageReturnLineFeed; + } + ts.getNewLineCharacter = getNewLineCharacter; + function createRange(pos, end) { + if (end === void 0) { end = pos; } + ts.Debug.assert(end >= pos || end === -1); + return { pos: pos, end: end }; + } + ts.createRange = createRange; + function moveRangeEnd(range, end) { + return createRange(range.pos, end); + } + ts.moveRangeEnd = moveRangeEnd; + function moveRangePos(range, pos) { + return createRange(pos, range.end); + } + ts.moveRangePos = moveRangePos; + function moveRangePastDecorators(node) { + return node.decorators && node.decorators.length > 0 + ? moveRangePos(node, node.decorators.end) + : node; + } + ts.moveRangePastDecorators = moveRangePastDecorators; + function moveRangePastModifiers(node) { + return node.modifiers && node.modifiers.length > 0 + ? moveRangePos(node, node.modifiers.end) + : moveRangePastDecorators(node); + } + ts.moveRangePastModifiers = moveRangePastModifiers; + function isCollapsedRange(range) { + return range.pos === range.end; + } + ts.isCollapsedRange = isCollapsedRange; + function createTokenRange(pos, token) { + return createRange(pos, pos + ts.tokenToString(token).length); + } + ts.createTokenRange = createTokenRange; + function rangeIsOnSingleLine(range, sourceFile) { + return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile); + } + ts.rangeIsOnSingleLine = rangeIsOnSingleLine; + function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) { + return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile), getStartPositionOfRange(range2, sourceFile), sourceFile); + } + ts.rangeStartPositionsAreOnSameLine = rangeStartPositionsAreOnSameLine; + function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) { + return positionsAreOnSameLine(range1.end, range2.end, sourceFile); + } + ts.rangeEndPositionsAreOnSameLine = rangeEndPositionsAreOnSameLine; + function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) { + return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile), range2.end, sourceFile); + } + ts.rangeStartIsOnSameLineAsRangeEnd = rangeStartIsOnSameLineAsRangeEnd; + function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) { + return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile), sourceFile); + } + ts.rangeEndIsOnSameLineAsRangeStart = rangeEndIsOnSameLineAsRangeStart; + function isNodeArrayMultiLine(list, sourceFile) { + return !positionsAreOnSameLine(list.pos, list.end, sourceFile); + } + ts.isNodeArrayMultiLine = isNodeArrayMultiLine; + function positionsAreOnSameLine(pos1, pos2, sourceFile) { + return pos1 === pos2 || + getLineOfLocalPosition(sourceFile, pos1) === getLineOfLocalPosition(sourceFile, pos2); + } + ts.positionsAreOnSameLine = positionsAreOnSameLine; + function getStartPositionOfRange(range, sourceFile) { + return positionIsSynthesized(range.pos) ? -1 : ts.skipTrivia(sourceFile.text, range.pos); + } + ts.getStartPositionOfRange = getStartPositionOfRange; + function isDeclarationNameOfEnumOrNamespace(node) { + var parseNode = ts.getParseTreeNode(node); + if (parseNode) { + switch (parseNode.parent.kind) { + case 248: + case 249: + return parseNode === parseNode.parent.name; + } + } + return false; + } + ts.isDeclarationNameOfEnumOrNamespace = isDeclarationNameOfEnumOrNamespace; + function getInitializedVariables(node) { + return ts.filter(node.declarations, isInitializedVariable); + } + ts.getInitializedVariables = getInitializedVariables; + function isInitializedVariable(node) { + return node.initializer !== undefined; + } + function isWatchSet(options) { + return options.watch && options.hasOwnProperty("watch"); + } + ts.isWatchSet = isWatchSet; + function closeFileWatcher(watcher) { + watcher.close(); + } + ts.closeFileWatcher = closeFileWatcher; + function getCheckFlags(symbol) { + return symbol.flags & 33554432 ? symbol.checkFlags : 0; + } + ts.getCheckFlags = getCheckFlags; + function getDeclarationModifierFlagsFromSymbol(s) { + if (s.valueDeclaration) { + var flags = ts.getCombinedModifierFlags(s.valueDeclaration); + return s.parent && s.parent.flags & 32 ? flags : flags & ~28; + } + if (getCheckFlags(s) & 6) { + var checkFlags = s.checkFlags; + var accessModifier = checkFlags & 1024 ? 8 : + checkFlags & 256 ? 4 : + 16; + var staticModifier = checkFlags & 2048 ? 32 : 0; + return accessModifier | staticModifier; + } + if (s.flags & 4194304) { + return 4 | 32; + } + return 0; + } + ts.getDeclarationModifierFlagsFromSymbol = getDeclarationModifierFlagsFromSymbol; + function skipAlias(symbol, checker) { + return symbol.flags & 2097152 ? checker.getAliasedSymbol(symbol) : symbol; + } + ts.skipAlias = skipAlias; + function getCombinedLocalAndExportSymbolFlags(symbol) { + return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags; + } + ts.getCombinedLocalAndExportSymbolFlags = getCombinedLocalAndExportSymbolFlags; + function isWriteOnlyAccess(node) { + return accessKind(node) === 1; + } + ts.isWriteOnlyAccess = isWriteOnlyAccess; + function isWriteAccess(node) { + return accessKind(node) !== 0; + } + ts.isWriteAccess = isWriteAccess; + function accessKind(node) { + var parent = node.parent; + if (!parent) + return 0; + switch (parent.kind) { + case 200: + return accessKind(parent); + case 208: + case 207: + var operator = parent.operator; + return operator === 45 || operator === 46 ? writeOrReadWrite() : 0; + case 209: + var _a = parent, left = _a.left, operatorToken = _a.operatorToken; + return left === node && isAssignmentOperator(operatorToken.kind) ? + operatorToken.kind === 62 ? 1 : writeOrReadWrite() + : 0; + case 194: + return parent.name !== node ? 0 : accessKind(parent); + case 281: { + var parentAccess = accessKind(parent.parent); + return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess; + } + case 282: + return node === parent.objectAssignmentInitializer ? 0 : accessKind(parent.parent); + case 192: + return accessKind(parent); + default: + return 0; + } + function writeOrReadWrite() { + return parent.parent && skipParenthesesUp(parent.parent).kind === 226 ? 1 : 2; + } + } + function reverseAccessKind(a) { + switch (a) { + case 0: + return 1; + case 1: + return 0; + case 2: + return 2; + default: + return ts.Debug.assertNever(a); + } + } + function compareDataObjects(dst, src) { + if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) { + return false; + } + for (var e in dst) { + if (typeof dst[e] === "object") { + if (!compareDataObjects(dst[e], src[e])) { + return false; + } + } + else if (typeof dst[e] !== "function") { + if (dst[e] !== src[e]) { + return false; + } + } + } + return true; + } + ts.compareDataObjects = compareDataObjects; + function clearMap(map, onDeleteValue) { + map.forEach(onDeleteValue); + map.clear(); + } + ts.clearMap = clearMap; + function mutateMapSkippingNewValues(map, newMap, options) { + var onDeleteValue = options.onDeleteValue, onExistingValue = options.onExistingValue; + map.forEach(function (existingValue, key) { + var valueInNewMap = newMap.get(key); + if (valueInNewMap === undefined) { + map.delete(key); + onDeleteValue(existingValue, key); + } + else if (onExistingValue) { + onExistingValue(existingValue, valueInNewMap, key); + } + }); + } + ts.mutateMapSkippingNewValues = mutateMapSkippingNewValues; + function mutateMap(map, newMap, options) { + mutateMapSkippingNewValues(map, newMap, options); + var createNewValue = options.createNewValue; + newMap.forEach(function (valueInNewMap, key) { + if (!map.has(key)) { + map.set(key, createNewValue(key, valueInNewMap)); + } + }); + } + ts.mutateMap = mutateMap; + function isAbstractConstructorType(type) { + return !!(getObjectFlags(type) & 16) && !!type.symbol && isAbstractConstructorSymbol(type.symbol); + } + ts.isAbstractConstructorType = isAbstractConstructorType; + function isAbstractConstructorSymbol(symbol) { + if (symbol.flags & 32) { + var declaration = getClassLikeDeclarationOfSymbol(symbol); + return !!declaration && hasModifier(declaration, 128); + } + return false; + } + ts.isAbstractConstructorSymbol = isAbstractConstructorSymbol; + function getClassLikeDeclarationOfSymbol(symbol) { + return ts.find(symbol.declarations, ts.isClassLike); + } + ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol; + function getObjectFlags(type) { + return type.flags & 3899393 ? type.objectFlags : 0; + } + ts.getObjectFlags = getObjectFlags; + function typeHasCallOrConstructSignatures(type, checker) { + return checker.getSignaturesOfType(type, 0).length !== 0 || checker.getSignaturesOfType(type, 1).length !== 0; + } + ts.typeHasCallOrConstructSignatures = typeHasCallOrConstructSignatures; + function forSomeAncestorDirectory(directory, callback) { + return !!ts.forEachAncestorDirectory(directory, function (d) { return callback(d) ? true : undefined; }); + } + ts.forSomeAncestorDirectory = forSomeAncestorDirectory; + function isUMDExportSymbol(symbol) { + return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && ts.isNamespaceExportDeclaration(symbol.declarations[0]); + } + ts.isUMDExportSymbol = isUMDExportSymbol; + function showModuleSpecifier(_a) { + var moduleSpecifier = _a.moduleSpecifier; + return ts.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : getTextOfNode(moduleSpecifier); + } + ts.showModuleSpecifier = showModuleSpecifier; + function getLastChild(node) { + var lastChild; + ts.forEachChild(node, function (child) { + if (nodeIsPresent(child)) + lastChild = child; + }, function (children) { + for (var i = children.length - 1; i >= 0; i--) { + if (nodeIsPresent(children[i])) { + lastChild = children[i]; + break; + } + } + }); + return lastChild; + } + ts.getLastChild = getLastChild; + function addToSeen(seen, key, value) { + if (value === void 0) { value = true; } + key = String(key); + if (seen.has(key)) { + return false; + } + seen.set(key, value); + return true; + } + ts.addToSeen = addToSeen; + function isObjectTypeDeclaration(node) { + return ts.isClassLike(node) || ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node); + } + ts.isObjectTypeDeclaration = isObjectTypeDeclaration; + function isTypeNodeKind(kind) { + return (kind >= 168 && kind <= 188) + || kind === 125 + || kind === 148 + || kind === 140 + || kind === 151 + || kind === 141 + || kind === 128 + || kind === 143 + || kind === 144 + || kind === 104 + || kind === 110 + || kind === 146 + || kind === 100 + || kind === 137 + || kind === 216 + || kind === 295 + || kind === 296 + || kind === 297 + || kind === 298 + || kind === 299 + || kind === 300 + || kind === 301; + } + ts.isTypeNodeKind = isTypeNodeKind; + function isAccessExpression(node) { + return node.kind === 194 || node.kind === 195; + } + ts.isAccessExpression = isAccessExpression; + function isBundleFileTextLike(section) { + switch (section.kind) { + case "text": + case "internal": + return true; + default: + return false; + } + } + ts.isBundleFileTextLike = isBundleFileTextLike; + function getDotOrQuestionDotToken(node) { + return node.questionDotToken || ts.createNode(24, node.expression.end, node.name.pos); + } + ts.getDotOrQuestionDotToken = getDotOrQuestionDotToken; + function isNamedImportsOrExports(node) { + return node.kind === 257 || node.kind === 261; + } + ts.isNamedImportsOrExports = isNamedImportsOrExports; + function Symbol(flags, name) { + this.flags = flags; + this.escapedName = name; + this.declarations = undefined; + this.valueDeclaration = undefined; + this.id = undefined; + this.mergeId = undefined; + this.parent = undefined; + } + function Type(checker, flags) { + this.flags = flags; + if (ts.Debug.isDebugging) { + this.checker = checker; + } + } + function Signature(checker, flags) { + this.flags = flags; + if (ts.Debug.isDebugging) { + this.checker = checker; + } + } + function Node(kind, pos, end) { + this.pos = pos; + this.end = end; + this.kind = kind; + this.id = 0; + this.flags = 0; + this.modifierFlagsCache = 0; + this.transformFlags = 0; + this.parent = undefined; + this.original = undefined; + } + function SourceMapSource(fileName, text, skipTrivia) { + this.fileName = fileName; + this.text = text; + this.skipTrivia = skipTrivia || (function (pos) { return pos; }); + } + ts.objectAllocator = { + getNodeConstructor: function () { return Node; }, + getTokenConstructor: function () { return Node; }, + getIdentifierConstructor: function () { return Node; }, + getPrivateIdentifierConstructor: function () { return Node; }, + getSourceFileConstructor: function () { return Node; }, + getSymbolConstructor: function () { return Symbol; }, + getTypeConstructor: function () { return Type; }, + getSignatureConstructor: function () { return Signature; }, + getSourceMapSourceConstructor: function () { return SourceMapSource; }, + }; + function setObjectAllocator(alloc) { + ts.objectAllocator = alloc; + } + ts.setObjectAllocator = setObjectAllocator; + function formatStringFromArgs(text, args, baseIndex) { + if (baseIndex === void 0) { baseIndex = 0; } + return text.replace(/{(\d+)}/g, function (_match, index) { return "" + ts.Debug.assertDefined(args[+index + baseIndex]); }); + } + ts.formatStringFromArgs = formatStringFromArgs; + function setLocalizedDiagnosticMessages(messages) { + ts.localizedDiagnosticMessages = messages; + } + ts.setLocalizedDiagnosticMessages = setLocalizedDiagnosticMessages; + function getLocaleSpecificMessage(message) { + return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message.key] || message.message; + } + ts.getLocaleSpecificMessage = getLocaleSpecificMessage; + function createFileDiagnostic(file, start, length, message) { + ts.Debug.assertGreaterThanOrEqual(start, 0); + ts.Debug.assertGreaterThanOrEqual(length, 0); + if (file) { + ts.Debug.assertLessThanOrEqual(start, file.text.length); + ts.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, + reportsUnnecessary: message.reportsUnnecessary, + }; + } + 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, + reportsUnnecessary: message.reportsUnnecessary, + }; + } + 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 === undefined || Array.isArray(details) ? details : [details] + }; + } + ts.chainDiagnosticMessages = chainDiagnosticMessages; + function concatenateDiagnosticMessageChains(headChain, tailChain) { + var lastChain = headChain; + while (lastChain.next) { + lastChain = lastChain.next[0]; + } + lastChain.next = [tailChain]; + } + ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains; + function getDiagnosticFilePath(diagnostic) { + return diagnostic.file ? diagnostic.file.path : undefined; + } + function compareDiagnostics(d1, d2) { + return compareDiagnosticsSkipRelatedInformation(d1, d2) || + compareRelatedInformation(d1, d2) || + 0; + } + ts.compareDiagnostics = compareDiagnostics; + function compareDiagnosticsSkipRelatedInformation(d1, d2) { + return ts.compareStringsCaseSensitive(getDiagnosticFilePath(d1), getDiagnosticFilePath(d2)) || + ts.compareValues(d1.start, d2.start) || + ts.compareValues(d1.length, d2.length) || + ts.compareValues(d1.code, d2.code) || + compareMessageText(d1.messageText, d2.messageText) || + 0; + } + ts.compareDiagnosticsSkipRelatedInformation = compareDiagnosticsSkipRelatedInformation; + function compareRelatedInformation(d1, d2) { + if (!d1.relatedInformation && !d2.relatedInformation) { + return 0; + } + if (d1.relatedInformation && d2.relatedInformation) { + return ts.compareValues(d1.relatedInformation.length, d2.relatedInformation.length) || ts.forEach(d1.relatedInformation, function (d1i, index) { + var d2i = d2.relatedInformation[index]; + return compareDiagnostics(d1i, d2i); + }) || 0; + } + return d1.relatedInformation ? -1 : 1; + } + function compareMessageText(t1, t2) { + if (typeof t1 === "string" && typeof t2 === "string") { + return ts.compareStringsCaseSensitive(t1, t2); + } + else if (typeof t1 === "string") { + return -1; + } + else if (typeof t2 === "string") { + return 1; + } + var res = ts.compareStringsCaseSensitive(t1.messageText, t2.messageText); + if (res) { + return res; + } + if (!t1.next && !t2.next) { + return 0; + } + if (!t1.next) { + return -1; + } + if (!t2.next) { + return 1; + } + var len = Math.min(t1.next.length, t2.next.length); + for (var i = 0; i < len; i++) { + res = compareMessageText(t1.next[i], t2.next[i]); + if (res) { + return res; + } + } + if (t1.next.length < t2.next.length) { + return -1; + } + else if (t1.next.length > t2.next.length) { + return 1; + } + return 0; + } + function getEmitScriptTarget(compilerOptions) { + return compilerOptions.target || 0; + } + ts.getEmitScriptTarget = getEmitScriptTarget; + function getEmitModuleKind(compilerOptions) { + return typeof compilerOptions.module === "number" ? + compilerOptions.module : + getEmitScriptTarget(compilerOptions) >= 2 ? ts.ModuleKind.ES2015 : ts.ModuleKind.CommonJS; + } + ts.getEmitModuleKind = getEmitModuleKind; + function getEmitModuleResolutionKind(compilerOptions) { + var moduleResolution = compilerOptions.moduleResolution; + if (moduleResolution === undefined) { + moduleResolution = getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic; + } + return moduleResolution; + } + ts.getEmitModuleResolutionKind = getEmitModuleResolutionKind; + function hasJsonModuleEmitEnabled(options) { + switch (getEmitModuleKind(options)) { + case ts.ModuleKind.CommonJS: + case ts.ModuleKind.AMD: + case ts.ModuleKind.ES2015: + case ts.ModuleKind.ES2020: + case ts.ModuleKind.ESNext: + return true; + default: + return false; + } + } + ts.hasJsonModuleEmitEnabled = hasJsonModuleEmitEnabled; + function unreachableCodeIsError(options) { + return options.allowUnreachableCode === false; + } + ts.unreachableCodeIsError = unreachableCodeIsError; + function unusedLabelIsError(options) { + return options.allowUnusedLabels === false; + } + ts.unusedLabelIsError = unusedLabelIsError; + function getAreDeclarationMapsEnabled(options) { + return !!(getEmitDeclarations(options) && options.declarationMap); + } + ts.getAreDeclarationMapsEnabled = getAreDeclarationMapsEnabled; + function getAllowSyntheticDefaultImports(compilerOptions) { + var moduleKind = getEmitModuleKind(compilerOptions); + return compilerOptions.allowSyntheticDefaultImports !== undefined + ? compilerOptions.allowSyntheticDefaultImports + : compilerOptions.esModuleInterop || + moduleKind === ts.ModuleKind.System; + } + ts.getAllowSyntheticDefaultImports = getAllowSyntheticDefaultImports; + function getEmitDeclarations(compilerOptions) { + return !!(compilerOptions.declaration || compilerOptions.composite); + } + ts.getEmitDeclarations = getEmitDeclarations; + function isIncrementalCompilation(options) { + return !!(options.incremental || options.composite); + } + ts.isIncrementalCompilation = isIncrementalCompilation; + function getStrictOptionValue(compilerOptions, flag) { + return compilerOptions[flag] === undefined ? !!compilerOptions.strict : !!compilerOptions[flag]; + } + ts.getStrictOptionValue = getStrictOptionValue; + function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) { + return oldOptions !== newOptions && + ts.semanticDiagnosticsOptionDeclarations.some(function (option) { return !isJsonEqual(getCompilerOptionValue(oldOptions, option), getCompilerOptionValue(newOptions, option)); }); + } + ts.compilerOptionsAffectSemanticDiagnostics = compilerOptionsAffectSemanticDiagnostics; + function compilerOptionsAffectEmit(newOptions, oldOptions) { + return oldOptions !== newOptions && + ts.affectsEmitOptionDeclarations.some(function (option) { return !isJsonEqual(getCompilerOptionValue(oldOptions, option), getCompilerOptionValue(newOptions, option)); }); + } + ts.compilerOptionsAffectEmit = compilerOptionsAffectEmit; + function getCompilerOptionValue(options, option) { + return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name]; + } + ts.getCompilerOptionValue = getCompilerOptionValue; + function hasZeroOrOneAsteriskCharacter(str) { + var seenAsterisk = false; + for (var i = 0; i < str.length; i++) { + if (str.charCodeAt(i) === 42) { + if (!seenAsterisk) { + seenAsterisk = true; + } + else { + return false; + } + } + } + return true; + } + ts.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter; + function discoverProbableSymlinks(files, getCanonicalFileName, cwd) { + var result = ts.createMap(); + var symlinks = ts.flatten(ts.mapDefined(files, function (sf) { + return sf.resolvedModules && ts.compact(ts.arrayFrom(ts.mapIterator(sf.resolvedModules.values(), function (res) { + return res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] : undefined; + }))); + })); + for (var _i = 0, symlinks_1 = symlinks; _i < symlinks_1.length; _i++) { + var _a = symlinks_1[_i], resolvedPath = _a[0], originalPath = _a[1]; + var _b = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName), commonResolved = _b[0], commonOriginal = _b[1]; + result.set(commonOriginal, commonResolved); + } + return result; + } + ts.discoverProbableSymlinks = discoverProbableSymlinks; + function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) { + var aParts = ts.getPathComponents(ts.toPath(a, cwd, getCanonicalFileName)); + var bParts = ts.getPathComponents(ts.toPath(b, cwd, getCanonicalFileName)); + while (!isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) && + !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) && + getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) { + aParts.pop(); + bParts.pop(); + } + return [ts.getPathFromPathComponents(aParts), ts.getPathFromPathComponents(bParts)]; + } + function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) { + return getCanonicalFileName(s) === "node_modules" || ts.startsWith(s, "@"); + } + function stripLeadingDirectorySeparator(s) { + return ts.isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : undefined; + } + function tryRemoveDirectoryPrefix(path, dirPath, getCanonicalFileName) { + var withoutPrefix = ts.tryRemovePrefix(path, dirPath, getCanonicalFileName); + return withoutPrefix === undefined ? undefined : stripLeadingDirectorySeparator(withoutPrefix); + } + ts.tryRemoveDirectoryPrefix = tryRemoveDirectoryPrefix; + var reservedCharacterPattern = /[^\w\s\/]/g; + function regExpEscape(text) { + return text.replace(reservedCharacterPattern, escapeRegExpCharacter); + } + ts.regExpEscape = regExpEscape; + function escapeRegExpCharacter(match) { + return "\\" + match; + } + var wildcardCharCodes = [42, 63]; + ts.commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"]; + var implicitExcludePathRegexPattern = "(?!(" + ts.commonPackageFolders.join("|") + ")(/|$))"; + var filesMatcher = { + singleAsteriskRegexFragment: "([^./]|(\\.(?!min\\.js$))?)*", + doubleAsteriskRegexFragment: "(/" + implicitExcludePathRegexPattern + "[^/.][^/]*)*?", + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment); } + }; + var directoriesMatcher = { + singleAsteriskRegexFragment: "[^/]*", + doubleAsteriskRegexFragment: "(/" + implicitExcludePathRegexPattern + "[^/.][^/]*)*?", + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment); } + }; + var excludeMatcher = { + singleAsteriskRegexFragment: "[^/]*", + doubleAsteriskRegexFragment: "(/.+?)?", + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment); } + }; + var wildcardMatchers = { + files: filesMatcher, + directories: directoriesMatcher, + exclude: excludeMatcher + }; + function getRegularExpressionForWildcard(specs, basePath, usage) { + var patterns = getRegularExpressionsForWildcards(specs, basePath, usage); + if (!patterns || !patterns.length) { + return undefined; + } + var pattern = patterns.map(function (pattern) { return "(" + pattern + ")"; }).join("|"); + var terminator = usage === "exclude" ? "($|/)" : "$"; + return "^(" + pattern + ")" + terminator; + } + ts.getRegularExpressionForWildcard = getRegularExpressionForWildcard; + function getRegularExpressionsForWildcards(specs, basePath, usage) { + if (specs === undefined || specs.length === 0) { + return undefined; + } + return ts.flatMap(specs, function (spec) { + return spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]); + }); + } + ts.getRegularExpressionsForWildcards = getRegularExpressionsForWildcards; + function isImplicitGlob(lastPathComponent) { + return !/[.*?]/.test(lastPathComponent); + } + ts.isImplicitGlob = isImplicitGlob; + function getSubPatternFromSpec(spec, basePath, usage, _a) { + var singleAsteriskRegexFragment = _a.singleAsteriskRegexFragment, doubleAsteriskRegexFragment = _a.doubleAsteriskRegexFragment, replaceWildcardCharacter = _a.replaceWildcardCharacter; + var subpattern = ""; + var hasWrittenComponent = false; + var components = ts.getNormalizedPathComponents(spec, basePath); + var lastComponent = ts.last(components); + if (usage !== "exclude" && lastComponent === "**") { + return undefined; + } + components[0] = ts.removeTrailingDirectorySeparator(components[0]); + if (isImplicitGlob(lastComponent)) { + components.push("**", "*"); + } + var optionalCount = 0; + for (var _i = 0, components_1 = components; _i < components_1.length; _i++) { + var component = components_1[_i]; + if (component === "**") { + subpattern += doubleAsteriskRegexFragment; + } + else { + if (usage === "directories") { + subpattern += "("; + optionalCount++; + } + if (hasWrittenComponent) { + subpattern += ts.directorySeparator; + } + if (usage !== "exclude") { + var componentPattern = ""; + if (component.charCodeAt(0) === 42) { + componentPattern += "([^./]" + singleAsteriskRegexFragment + ")?"; + component = component.substr(1); + } + else if (component.charCodeAt(0) === 63) { + componentPattern += "[^./]"; + component = component.substr(1); + } + componentPattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter); + if (componentPattern !== component) { + subpattern += implicitExcludePathRegexPattern; + } + subpattern += componentPattern; + } + else { + subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter); + } + } + hasWrittenComponent = true; + } + while (optionalCount > 0) { + subpattern += ")?"; + optionalCount--; + } + return subpattern; + } + function replaceWildcardCharacter(match, singleAsteriskRegexFragment) { + return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match; + } + function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) { + path = ts.normalizePath(path); + currentDirectory = ts.normalizePath(currentDirectory); + var absolutePath = ts.combinePaths(currentDirectory, path); + return { + includeFilePatterns: ts.map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), function (pattern) { return "^" + pattern + "$"; }), + includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"), + includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"), + excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"), + basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames) + }; + } + ts.getFileMatcherPatterns = getFileMatcherPatterns; + function getRegexFromPattern(pattern, useCaseSensitiveFileNames) { + return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i"); + } + ts.getRegexFromPattern = getRegexFromPattern; + function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) { + path = ts.normalizePath(path); + currentDirectory = ts.normalizePath(currentDirectory); + var patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory); + var includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(function (pattern) { return getRegexFromPattern(pattern, useCaseSensitiveFileNames); }); + var includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames); + var excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames); + var results = includeFileRegexes ? includeFileRegexes.map(function () { return []; }) : [[]]; + var visited = ts.createMap(); + var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) { + var basePath = _a[_i]; + visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth); + } + return ts.flatten(results); + function visitDirectory(path, absolutePath, depth) { + var canonicalPath = toCanonical(realpath(absolutePath)); + if (visited.has(canonicalPath)) + return; + visited.set(canonicalPath, true); + var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories; + var _loop_1 = function (current) { + var name = ts.combinePaths(path, current); + var absoluteName = ts.combinePaths(absolutePath, current); + if (extensions && !ts.fileExtensionIsOneOf(name, extensions)) + return "continue"; + if (excludeRegex && excludeRegex.test(absoluteName)) + return "continue"; + if (!includeFileRegexes) { + results[0].push(name); + } + else { + var includeIndex = ts.findIndex(includeFileRegexes, function (re) { return re.test(absoluteName); }); + if (includeIndex !== -1) { + results[includeIndex].push(name); + } + } + }; + for (var _i = 0, _b = ts.sort(files, ts.compareStringsCaseSensitive); _i < _b.length; _i++) { + var current = _b[_i]; + _loop_1(current); + } + if (depth !== undefined) { + depth--; + if (depth === 0) { + return; + } + } + for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) { + var current = _d[_c]; + var name = ts.combinePaths(path, current); + var absoluteName = ts.combinePaths(absolutePath, current); + if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && + (!excludeRegex || !excludeRegex.test(absoluteName))) { + visitDirectory(name, absoluteName, depth); + } + } + } + } + ts.matchFiles = matchFiles; + function getBasePaths(path, includes, useCaseSensitiveFileNames) { + var basePaths = [path]; + if (includes) { + var includeBasePaths = []; + for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) { + var include = includes_1[_i]; + var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include)); + includeBasePaths.push(getIncludeBasePath(absolute)); + } + includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames)); + var _loop_2 = function (includeBasePath) { + if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) { + basePaths.push(includeBasePath); + } + }; + for (var _a = 0, includeBasePaths_1 = includeBasePaths; _a < includeBasePaths_1.length; _a++) { + var includeBasePath = includeBasePaths_1[_a]; + _loop_2(includeBasePath); + } + } + return basePaths; + } + function getIncludeBasePath(absolute) { + var wildcardOffset = ts.indexOfAnyCharCode(absolute, wildcardCharCodes); + if (wildcardOffset < 0) { + return !ts.hasExtension(absolute) + ? absolute + : ts.removeTrailingDirectorySeparator(ts.getDirectoryPath(absolute)); + } + return absolute.substring(0, absolute.lastIndexOf(ts.directorySeparator, wildcardOffset)); + } + function ensureScriptKind(fileName, scriptKind) { + return scriptKind || getScriptKindFromFileName(fileName) || 3; + } + ts.ensureScriptKind = ensureScriptKind; + function getScriptKindFromFileName(fileName) { + var ext = fileName.substr(fileName.lastIndexOf(".")); + switch (ext.toLowerCase()) { + case ".js": + return 1; + case ".jsx": + return 2; + case ".ts": + return 3; + case ".tsx": + return 4; + case ".json": + return 6; + default: + return 0; + } + } + ts.getScriptKindFromFileName = getScriptKindFromFileName; + ts.supportedTSExtensions = [".ts", ".tsx", ".d.ts"]; + ts.supportedTSExtensionsWithJson = [".ts", ".tsx", ".d.ts", ".json"]; + ts.supportedTSExtensionsForExtractExtension = [".d.ts", ".ts", ".tsx"]; + ts.supportedJSExtensions = [".js", ".jsx"]; + ts.supportedJSAndJsonExtensions = [".js", ".jsx", ".json"]; + var allSupportedExtensions = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions); + var allSupportedExtensionsWithJson = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions, [".json"]); + function getSupportedExtensions(options, extraFileExtensions) { + var needJsExtensions = options && options.allowJs; + if (!extraFileExtensions || extraFileExtensions.length === 0) { + return needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions; + } + var extensions = __spreadArrays(needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions, ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 || needJsExtensions && isJSLike(x.scriptKind) ? x.extension : undefined; })); + return ts.deduplicate(extensions, ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); + } + ts.getSupportedExtensions = getSupportedExtensions; + function getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) { + if (!options || !options.resolveJsonModule) { + return supportedExtensions; + } + if (supportedExtensions === allSupportedExtensions) { + return allSupportedExtensionsWithJson; + } + if (supportedExtensions === ts.supportedTSExtensions) { + return ts.supportedTSExtensionsWithJson; + } + return __spreadArrays(supportedExtensions, [".json"]); + } + ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule; + function isJSLike(scriptKind) { + return scriptKind === 1 || scriptKind === 2; + } + function hasJSFileExtension(fileName) { + return ts.some(ts.supportedJSExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.hasJSFileExtension = hasJSFileExtension; + function hasTSFileExtension(fileName) { + return ts.some(ts.supportedTSExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.hasTSFileExtension = hasTSFileExtension; + function isSupportedSourceFileName(fileName, compilerOptions, extraFileExtensions) { + if (!fileName) { + return false; + } + var supportedExtensions = getSupportedExtensions(compilerOptions, extraFileExtensions); + for (var _i = 0, _a = getSuppoertedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions); _i < _a.length; _i++) { + var extension = _a[_i]; + if (ts.fileExtensionIs(fileName, extension)) { + return true; + } + } + return false; + } + ts.isSupportedSourceFileName = isSupportedSourceFileName; + function getExtensionPriority(path, supportedExtensions) { + for (var i = supportedExtensions.length - 1; i >= 0; i--) { + if (ts.fileExtensionIs(path, supportedExtensions[i])) { + return adjustExtensionPriority(i, supportedExtensions); + } + } + return 0; + } + ts.getExtensionPriority = getExtensionPriority; + function adjustExtensionPriority(extensionPriority, supportedExtensions) { + if (extensionPriority < 2) { + return 0; + } + else if (extensionPriority < supportedExtensions.length) { + return 2; + } + else { + return supportedExtensions.length; + } + } + ts.adjustExtensionPriority = adjustExtensionPriority; + function getNextLowestExtensionPriority(extensionPriority, supportedExtensions) { + if (extensionPriority < 2) { + return 2; + } + else { + return supportedExtensions.length; + } + } + ts.getNextLowestExtensionPriority = getNextLowestExtensionPriority; + var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx", ".json"]; + function removeFileExtension(path) { + for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) { + var ext = extensionsToRemove_1[_i]; + var extensionless = tryRemoveExtension(path, ext); + if (extensionless !== undefined) { + return extensionless; + } + } + return path; + } + ts.removeFileExtension = removeFileExtension; + function tryRemoveExtension(path, extension) { + return ts.fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined; + } + ts.tryRemoveExtension = tryRemoveExtension; + function removeExtension(path, extension) { + return path.substring(0, path.length - extension.length); + } + ts.removeExtension = removeExtension; + function changeExtension(path, newExtension) { + return ts.changeAnyExtension(path, newExtension, extensionsToRemove, false); + } + ts.changeExtension = changeExtension; + function tryParsePattern(pattern) { + ts.Debug.assert(hasZeroOrOneAsteriskCharacter(pattern)); + var indexOfStar = pattern.indexOf("*"); + return indexOfStar === -1 ? undefined : { + prefix: pattern.substr(0, indexOfStar), + suffix: pattern.substr(indexOfStar + 1) + }; + } + ts.tryParsePattern = tryParsePattern; + function positionIsSynthesized(pos) { + return !(pos >= 0); + } + ts.positionIsSynthesized = positionIsSynthesized; + function extensionIsTS(ext) { + return ext === ".ts" || ext === ".tsx" || ext === ".d.ts"; + } + ts.extensionIsTS = extensionIsTS; + function resolutionExtensionIsTSOrJson(ext) { + return extensionIsTS(ext) || ext === ".json"; + } + ts.resolutionExtensionIsTSOrJson = resolutionExtensionIsTSOrJson; + function extensionFromPath(path) { + var ext = tryGetExtensionFromPath(path); + return ext !== undefined ? ext : ts.Debug.fail("File " + path + " has unknown extension."); + } + ts.extensionFromPath = extensionFromPath; + function isAnySupportedFileExtension(path) { + return tryGetExtensionFromPath(path) !== undefined; + } + ts.isAnySupportedFileExtension = isAnySupportedFileExtension; + function tryGetExtensionFromPath(path) { + return ts.find(extensionsToRemove, function (e) { return ts.fileExtensionIs(path, e); }); + } + ts.tryGetExtensionFromPath = tryGetExtensionFromPath; + function isCheckJsEnabledForFile(sourceFile, compilerOptions) { + return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs; + } + ts.isCheckJsEnabledForFile = isCheckJsEnabledForFile; + ts.emptyFileSystemEntries = { + files: ts.emptyArray, + directories: ts.emptyArray + }; + function matchPatternOrExact(patternStrings, candidate) { + var patterns = []; + for (var _i = 0, patternStrings_1 = patternStrings; _i < patternStrings_1.length; _i++) { + var patternString = patternStrings_1[_i]; + if (!hasZeroOrOneAsteriskCharacter(patternString)) + continue; + var pattern = tryParsePattern(patternString); + if (pattern) { + patterns.push(pattern); + } + else if (patternString === candidate) { + return patternString; + } + } + return ts.findBestPatternMatch(patterns, function (_) { return _; }, candidate); + } + ts.matchPatternOrExact = matchPatternOrExact; + function sliceAfter(arr, value) { + var index = arr.indexOf(value); + ts.Debug.assert(index !== -1); + return arr.slice(index); + } + ts.sliceAfter = sliceAfter; + function addRelatedInfo(diagnostic) { + var _a; + var relatedInformation = []; + for (var _i = 1; _i < arguments.length; _i++) { + relatedInformation[_i - 1] = arguments[_i]; + } + if (!relatedInformation.length) { + return diagnostic; + } + if (!diagnostic.relatedInformation) { + diagnostic.relatedInformation = []; + } + (_a = diagnostic.relatedInformation).push.apply(_a, relatedInformation); + return diagnostic; + } + ts.addRelatedInfo = addRelatedInfo; + function minAndMax(arr, getValue) { + ts.Debug.assert(arr.length !== 0); + var min = getValue(arr[0]); + var max = min; + for (var i = 1; i < arr.length; i++) { + var value = getValue(arr[i]); + if (value < min) { + min = value; + } + else if (value > max) { + max = value; + } + } + return { min: min, max: max }; + } + ts.minAndMax = minAndMax; + var NodeSet = (function () { + function NodeSet() { + this.map = ts.createMap(); + } + NodeSet.prototype.add = function (node) { + this.map.set(String(ts.getNodeId(node)), node); + }; + NodeSet.prototype.tryAdd = function (node) { + if (this.has(node)) + return false; + this.add(node); + return true; + }; + NodeSet.prototype.has = function (node) { + return this.map.has(String(ts.getNodeId(node))); + }; + NodeSet.prototype.forEach = function (cb) { + this.map.forEach(cb); + }; + NodeSet.prototype.some = function (pred) { + return forEachEntry(this.map, pred) || false; + }; + return NodeSet; + }()); + ts.NodeSet = NodeSet; + var NodeMap = (function () { + function NodeMap() { + this.map = ts.createMap(); + } + NodeMap.prototype.get = function (node) { + var res = this.map.get(String(ts.getNodeId(node))); + return res && res.value; + }; + NodeMap.prototype.getOrUpdate = function (node, setValue) { + var res = this.get(node); + if (res) + return res; + var value = setValue(); + this.set(node, value); + return value; + }; + NodeMap.prototype.set = function (node, value) { + this.map.set(String(ts.getNodeId(node)), { node: node, value: value }); + }; + NodeMap.prototype.has = function (node) { + return this.map.has(String(ts.getNodeId(node))); + }; + NodeMap.prototype.forEach = function (cb) { + this.map.forEach(function (_a) { + var node = _a.node, value = _a.value; + return cb(value, node); + }); + }; + return NodeMap; + }()); + ts.NodeMap = NodeMap; + function rangeOfNode(node) { + return { pos: getTokenPosOfNode(node), end: node.end }; + } + ts.rangeOfNode = rangeOfNode; + function rangeOfTypeParameters(typeParameters) { + return { pos: typeParameters.pos - 1, end: typeParameters.end + 1 }; + } + ts.rangeOfTypeParameters = rangeOfTypeParameters; + function skipTypeChecking(sourceFile, options, host) { + return (options.skipLibCheck && sourceFile.isDeclarationFile || + options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib) || + host.isSourceOfProjectReferenceRedirect(sourceFile.fileName); + } + ts.skipTypeChecking = skipTypeChecking; + function isJsonEqual(a, b) { + return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && ts.equalOwnProperties(a, b, isJsonEqual); + } + ts.isJsonEqual = isJsonEqual; + function getOrUpdate(map, key, getDefault) { + var got = map.get(key); + if (got === undefined) { + var value = getDefault(); + map.set(key, value); + return value; + } + else { + return got; + } + } + ts.getOrUpdate = getOrUpdate; + function parsePseudoBigInt(stringValue) { + var log2Base; + switch (stringValue.charCodeAt(1)) { + case 98: + case 66: + log2Base = 1; + break; + case 111: + case 79: + log2Base = 3; + break; + case 120: + case 88: + log2Base = 4; + break; + default: + var nIndex = stringValue.length - 1; + var nonZeroStart = 0; + while (stringValue.charCodeAt(nonZeroStart) === 48) { + nonZeroStart++; + } + return stringValue.slice(nonZeroStart, nIndex) || "0"; + } + var startIndex = 2, endIndex = stringValue.length - 1; + var bitsNeeded = (endIndex - startIndex) * log2Base; + var segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0)); + for (var i = endIndex - 1, bitOffset = 0; i >= startIndex; i--, bitOffset += log2Base) { + var segment = bitOffset >>> 4; + var digitChar = stringValue.charCodeAt(i); + var digit = digitChar <= 57 + ? digitChar - 48 + : 10 + digitChar - + (digitChar <= 70 ? 65 : 97); + var shiftedDigit = digit << (bitOffset & 15); + segments[segment] |= shiftedDigit; + var residual = shiftedDigit >>> 16; + if (residual) + segments[segment + 1] |= residual; + } + var base10Value = ""; + var firstNonzeroSegment = segments.length - 1; + var segmentsRemaining = true; + while (segmentsRemaining) { + var mod10 = 0; + segmentsRemaining = false; + for (var segment = firstNonzeroSegment; segment >= 0; segment--) { + var newSegment = mod10 << 16 | segments[segment]; + var segmentValue = (newSegment / 10) | 0; + segments[segment] = segmentValue; + mod10 = newSegment - segmentValue * 10; + if (segmentValue && !segmentsRemaining) { + firstNonzeroSegment = segment; + segmentsRemaining = true; + } + } + base10Value = mod10 + base10Value; + } + return base10Value; + } + ts.parsePseudoBigInt = parsePseudoBigInt; + function pseudoBigIntToString(_a) { + var negative = _a.negative, base10Value = _a.base10Value; + return (negative && base10Value !== "0" ? "-" : "") + base10Value; + } + ts.pseudoBigIntToString = pseudoBigIntToString; + function isValidTypeOnlyAliasUseSite(useSite) { + return !!(useSite.flags & 8388608) + || isPartOfTypeQuery(useSite) + || isFirstIdentifierOfNonEmittingHeritageClause(useSite) + || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) + || !isExpressionNode(useSite); + } + ts.isValidTypeOnlyAliasUseSite = isValidTypeOnlyAliasUseSite; + function typeOnlyDeclarationIsExport(typeOnlyDeclaration) { + return typeOnlyDeclaration.kind === 263; + } + ts.typeOnlyDeclarationIsExport = typeOnlyDeclarationIsExport; + function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) { + while (node.kind === 75 || node.kind === 194) { + node = node.parent; + } + if (node.kind !== 154) { + return false; + } + if (hasModifier(node.parent, 128)) { + return true; + } + var containerKind = node.parent.parent.kind; + return containerKind === 246 || containerKind === 173; + } + function isFirstIdentifierOfNonEmittingHeritageClause(node) { + var _a, _b; + var heritageClause = (_a = ts.tryCast(node.parent.parent, ts.isHeritageClause)) !== null && _a !== void 0 ? _a : ts.tryCast((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.parent, ts.isHeritageClause); + return (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.token) === 113 || (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.parent.kind) === 246; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var NodeConstructor; + var TokenConstructor; + var IdentifierConstructor; + var PrivateIdentifierConstructor; + var SourceFileConstructor; + function createNode(kind, pos, end) { + if (kind === 290) { + return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, pos, end); + } + else if (kind === 75) { + return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, pos, end); + } + else if (kind === 76) { + return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, pos, end); + } + else if (!ts.isNodeKind(kind)) { + return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, pos, end); + } + else { + return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, pos, end); + } + } + ts.createNode = createNode; + function visitNode(cbNode, node) { + return node && cbNode(node); + } + function visitNodes(cbNode, cbNodes, nodes) { + if (nodes) { + if (cbNodes) { + return cbNodes(nodes); + } + for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) { + var node = nodes_1[_i]; + var result = cbNode(node); + if (result) { + return result; + } + } + } + } + function isJSDocLikeText(text, start) { + return text.charCodeAt(start + 1) === 42 && + text.charCodeAt(start + 2) === 42 && + text.charCodeAt(start + 3) !== 47; + } + ts.isJSDocLikeText = isJSDocLikeText; + function forEachChild(node, cbNode, cbNodes) { + if (!node || node.kind <= 152) { + return; + } + switch (node.kind) { + case 153: + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + case 155: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.constraint) || + visitNode(cbNode, node.default) || + visitNode(cbNode, node.expression); + case 282: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.equalsToken) || + visitNode(cbNode, node.objectAssignmentInitializer); + case 283: + return visitNode(cbNode, node.expression); + case 156: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + case 159: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + case 158: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + case 281: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.initializer); + case 242: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + case 191: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 170: + case 171: + case 165: + case 166: + case 167: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + case 161: + case 160: + case 162: + case 163: + case 164: + case 201: + case 244: + case 202: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.equalsGreaterThanToken) || + visitNode(cbNode, node.body); + case 169: + return visitNode(cbNode, node.typeName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + case 168: + return visitNode(cbNode, node.assertsModifier) || + visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + case 172: + return visitNode(cbNode, node.exprName); + case 173: + return visitNodes(cbNode, cbNodes, node.members); + case 174: + return visitNode(cbNode, node.elementType); + case 175: + return visitNodes(cbNode, cbNodes, node.elementTypes); + case 178: + case 179: + return visitNodes(cbNode, cbNodes, node.types); + case 180: + return visitNode(cbNode, node.checkType) || + visitNode(cbNode, node.extendsType) || + visitNode(cbNode, node.trueType) || + visitNode(cbNode, node.falseType); + case 181: + return visitNode(cbNode, node.typeParameter); + case 188: + return visitNode(cbNode, node.argument) || + visitNode(cbNode, node.qualifier) || + visitNodes(cbNode, cbNodes, node.typeArguments); + case 182: + case 184: + return visitNode(cbNode, node.type); + case 185: + return visitNode(cbNode, node.objectType) || + visitNode(cbNode, node.indexType); + case 186: + return visitNode(cbNode, node.readonlyToken) || + visitNode(cbNode, node.typeParameter) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type); + case 187: + return visitNode(cbNode, node.literal); + case 189: + case 190: + return visitNodes(cbNode, cbNodes, node.elements); + case 192: + return visitNodes(cbNode, cbNodes, node.elements); + case 193: + return visitNodes(cbNode, cbNodes, node.properties); + case 194: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.name); + case 195: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.argumentExpression); + case 196: + case 197: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNodes(cbNode, cbNodes, node.arguments); + case 198: + return visitNode(cbNode, node.tag) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.template); + case 199: + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.expression); + case 200: + return visitNode(cbNode, node.expression); + case 203: + return visitNode(cbNode, node.expression); + case 204: + return visitNode(cbNode, node.expression); + case 205: + return visitNode(cbNode, node.expression); + case 207: + return visitNode(cbNode, node.operand); + case 212: + return visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.expression); + case 206: + return visitNode(cbNode, node.expression); + case 208: + return visitNode(cbNode, node.operand); + case 209: + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.operatorToken) || + visitNode(cbNode, node.right); + case 217: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.type); + case 218: + return visitNode(cbNode, node.expression); + case 219: + return visitNode(cbNode, node.name); + case 210: + return visitNode(cbNode, node.condition) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.whenTrue) || + visitNode(cbNode, node.colonToken) || + visitNode(cbNode, node.whenFalse); + case 213: + return visitNode(cbNode, node.expression); + case 223: + case 250: + return visitNodes(cbNode, cbNodes, node.statements); + case 290: + return visitNodes(cbNode, cbNodes, node.statements) || + visitNode(cbNode, node.endOfFileToken); + case 225: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.declarationList); + case 243: + return visitNodes(cbNode, cbNodes, node.declarations); + case 226: + return visitNode(cbNode, node.expression); + case 227: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.thenStatement) || + visitNode(cbNode, node.elseStatement); + case 228: + return visitNode(cbNode, node.statement) || + visitNode(cbNode, node.expression); + case 229: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 230: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.condition) || + visitNode(cbNode, node.incrementor) || + visitNode(cbNode, node.statement); + case 231: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 232: + return visitNode(cbNode, node.awaitModifier) || + visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 233: + case 234: + return visitNode(cbNode, node.label); + case 235: + return visitNode(cbNode, node.expression); + case 236: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 237: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + case 251: + return visitNodes(cbNode, cbNodes, node.clauses); + case 277: + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.statements); + case 278: + return visitNodes(cbNode, cbNodes, node.statements); + case 238: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 239: + return visitNode(cbNode, node.expression); + case 240: + return visitNode(cbNode, node.tryBlock) || + visitNode(cbNode, node.catchClause) || + visitNode(cbNode, node.finallyBlock); + case 280: + return visitNode(cbNode, node.variableDeclaration) || + visitNode(cbNode, node.block); + case 157: + return visitNode(cbNode, node.expression); + case 245: + case 214: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + case 246: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + case 247: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + case 248: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.members); + case 284: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 249: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + case 253: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.moduleReference); + case 254: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier); + case 255: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + case 252: + return visitNode(cbNode, node.name); + case 256: + return visitNode(cbNode, node.name); + case 262: + return visitNode(cbNode, node.name); + case 257: + case 261: + return visitNodes(cbNode, cbNodes, node.elements); + case 260: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier); + case 258: + case 263: + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + case 259: + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.expression); + case 211: + return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans); + case 221: + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); + case 154: + return visitNode(cbNode, node.expression); + case 279: + return visitNodes(cbNode, cbNodes, node.types); + case 216: + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.typeArguments); + case 265: + return visitNode(cbNode, node.expression); + case 264: + return visitNodes(cbNode, cbNodes, node.decorators); + case 326: + return visitNodes(cbNode, cbNodes, node.elements); + case 266: + return visitNode(cbNode, node.openingElement) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingElement); + case 270: + return visitNode(cbNode, node.openingFragment) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingFragment); + case 267: + case 268: + return visitNode(cbNode, node.tagName) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.attributes); + case 274: + return visitNodes(cbNode, cbNodes, node.properties); + case 273: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 275: + return visitNode(cbNode, node.expression); + case 276: + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.expression); + case 269: + return visitNode(cbNode, node.tagName); + case 176: + case 177: + case 294: + case 298: + case 297: + case 299: + case 301: + return visitNode(cbNode, node.type); + case 300: + return visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + case 303: + return visitNodes(cbNode, cbNodes, node.tags); + case 316: + case 322: + return visitNode(cbNode, node.tagName) || + (node.isNameFirst + ? visitNode(cbNode, node.name) || + visitNode(cbNode, node.typeExpression) + : visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.name)); + case 308: + return visitNode(cbNode, node.tagName); + case 307: + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class); + case 320: + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.constraint) || + visitNodes(cbNode, cbNodes, node.typeParameters); + case 321: + return visitNode(cbNode, node.tagName) || + (node.typeExpression && + node.typeExpression.kind === 294 + ? visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.fullName) + : visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression)); + case 314: + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression); + case 317: + case 319: + case 318: + case 315: + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.typeExpression); + case 305: + return ts.forEach(node.typeParameters, cbNode) || + ts.forEach(node.parameters, cbNode) || + visitNode(cbNode, node.type); + case 304: + return ts.forEach(node.jsDocPropertyTags, cbNode); + case 306: + case 309: + case 310: + case 311: + case 312: + case 313: + return visitNode(cbNode, node.tagName); + case 325: + return visitNode(cbNode, node.expression); + } + } + ts.forEachChild = forEachChild; + function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) { + if (setParentNodes === void 0) { setParentNodes = false; } + ts.performance.mark("beforeParse"); + var result; + ts.perfLogger.logStartParseSourceFile(fileName); + if (languageVersion === 100) { + result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, 6); + } + else { + result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, scriptKind); + } + ts.perfLogger.logStopParseSourceFile(); + ts.performance.mark("afterParse"); + ts.performance.measure("Parse", "beforeParse", "afterParse"); + return result; + } + ts.createSourceFile = createSourceFile; + function parseIsolatedEntityName(text, languageVersion) { + return Parser.parseIsolatedEntityName(text, languageVersion); + } + ts.parseIsolatedEntityName = parseIsolatedEntityName; + function parseJsonText(fileName, sourceText) { + return Parser.parseJsonText(fileName, sourceText); + } + ts.parseJsonText = parseJsonText; + function isExternalModule(file) { + return file.externalModuleIndicator !== undefined; + } + ts.isExternalModule = isExternalModule; + function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { + if (aggressiveChecks === void 0) { aggressiveChecks = false; } + var newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks); + newSourceFile.flags |= (sourceFile.flags & 3145728); + return newSourceFile; + } + ts.updateSourceFile = updateSourceFile; + function parseIsolatedJSDocComment(content, start, length) { + var result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length); + if (result && result.jsDoc) { + Parser.fixupParentReferences(result.jsDoc); + } + return result; + } + ts.parseIsolatedJSDocComment = parseIsolatedJSDocComment; + function parseJSDocTypeExpressionForTests(content, start, length) { + return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length); + } + ts.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests; + var Parser; + (function (Parser) { + var scanner = ts.createScanner(99, true); + var disallowInAndDecoratorContext = 4096 | 16384; + var NodeConstructor; + var TokenConstructor; + var IdentifierConstructor; + var PrivateIdentifierConstructor; + var SourceFileConstructor; + var sourceFile; + var parseDiagnostics; + var syntaxCursor; + var currentToken; + var sourceText; + var nodeCount; + var identifiers; + var privateIdentifiers; + var identifierCount; + var parsingContext; + var notParenthesizedArrow; + var contextFlags; + var parseErrorBeforeNextFinishedNode = false; + function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind) { + if (setParentNodes === void 0) { setParentNodes = false; } + scriptKind = ts.ensureScriptKind(fileName, scriptKind); + if (scriptKind === 6) { + var result_2 = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes); + ts.convertToObjectWorker(result_2, result_2.parseDiagnostics, false, undefined, undefined); + result_2.referencedFiles = ts.emptyArray; + result_2.typeReferenceDirectives = ts.emptyArray; + result_2.libReferenceDirectives = ts.emptyArray; + result_2.amdDependencies = ts.emptyArray; + result_2.hasNoDefaultLib = false; + result_2.pragmas = ts.emptyMap; + return result_2; + } + initializeState(sourceText, languageVersion, syntaxCursor, scriptKind); + var result = parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind); + clearState(); + return result; + } + Parser.parseSourceFile = parseSourceFile; + function parseIsolatedEntityName(content, languageVersion) { + initializeState(content, languageVersion, undefined, 1); + nextToken(); + var entityName = parseEntityName(true); + var isInvalid = token() === 1 && !parseDiagnostics.length; + clearState(); + return isInvalid ? entityName : undefined; + } + Parser.parseIsolatedEntityName = parseIsolatedEntityName; + function parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes) { + if (languageVersion === void 0) { languageVersion = 2; } + initializeState(sourceText, languageVersion, syntaxCursor, 6); + sourceFile = createSourceFile(fileName, 2, 6, false); + sourceFile.flags = contextFlags; + nextToken(); + var pos = getNodePos(); + if (token() === 1) { + sourceFile.statements = createNodeArray([], pos, pos); + sourceFile.endOfFileToken = parseTokenNode(); + } + else { + var statement = createNode(226); + switch (token()) { + case 22: + statement.expression = parseArrayLiteralExpression(); + break; + case 106: + case 91: + case 100: + statement.expression = parseTokenNode(); + break; + case 40: + if (lookAhead(function () { return nextToken() === 8 && nextToken() !== 58; })) { + statement.expression = parsePrefixUnaryExpression(); + } + else { + statement.expression = parseObjectLiteralExpression(); + } + break; + case 8: + case 10: + if (lookAhead(function () { return nextToken() !== 58; })) { + statement.expression = parseLiteralNode(); + break; + } + default: + statement.expression = parseObjectLiteralExpression(); + break; + } + finishNode(statement); + sourceFile.statements = createNodeArray([statement], pos); + sourceFile.endOfFileToken = parseExpectedToken(1, ts.Diagnostics.Unexpected_token); + } + if (setParentNodes) { + fixupParentReferences(sourceFile); + } + sourceFile.nodeCount = nodeCount; + sourceFile.identifierCount = identifierCount; + sourceFile.identifiers = identifiers; + sourceFile.parseDiagnostics = parseDiagnostics; + var result = sourceFile; + clearState(); + return result; + } + Parser.parseJsonText = parseJsonText; + function getLanguageVariant(scriptKind) { + return scriptKind === 4 || scriptKind === 2 || scriptKind === 1 || scriptKind === 6 ? 1 : 0; + } + function initializeState(_sourceText, languageVersion, _syntaxCursor, scriptKind) { + NodeConstructor = ts.objectAllocator.getNodeConstructor(); + TokenConstructor = ts.objectAllocator.getTokenConstructor(); + IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor(); + PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor(); + SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor(); + sourceText = _sourceText; + syntaxCursor = _syntaxCursor; + parseDiagnostics = []; + parsingContext = 0; + identifiers = ts.createMap(); + privateIdentifiers = ts.createMap(); + identifierCount = 0; + nodeCount = 0; + switch (scriptKind) { + case 1: + case 2: + contextFlags = 131072; + break; + case 6: + contextFlags = 131072 | 33554432; + break; + default: + contextFlags = 0; + break; + } + parseErrorBeforeNextFinishedNode = false; + scanner.setText(sourceText); + scanner.setOnError(scanError); + scanner.setScriptTarget(languageVersion); + scanner.setLanguageVariant(getLanguageVariant(scriptKind)); + } + function clearState() { + scanner.setText(""); + scanner.setOnError(undefined); + parseDiagnostics = undefined; + sourceFile = undefined; + identifiers = undefined; + syntaxCursor = undefined; + sourceText = undefined; + notParenthesizedArrow = undefined; + } + function parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind) { + var isDeclarationFile = isDeclarationFileName(fileName); + if (isDeclarationFile) { + contextFlags |= 8388608; + } + sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile); + sourceFile.flags = contextFlags; + nextToken(); + processCommentPragmas(sourceFile, sourceText); + processPragmasIntoFields(sourceFile, reportPragmaDiagnostic); + sourceFile.statements = parseList(0, parseStatement); + ts.Debug.assert(token() === 1); + sourceFile.endOfFileToken = addJSDocComment(parseTokenNode()); + setExternalModuleIndicator(sourceFile); + sourceFile.nodeCount = nodeCount; + sourceFile.identifierCount = identifierCount; + sourceFile.identifiers = identifiers; + sourceFile.parseDiagnostics = parseDiagnostics; + if (setParentNodes) { + fixupParentReferences(sourceFile); + } + return sourceFile; + function reportPragmaDiagnostic(pos, end, diagnostic) { + parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, pos, end, diagnostic)); + } + } + function addJSDocComment(node) { + ts.Debug.assert(!node.jsDoc); + var jsDoc = ts.mapDefined(ts.getJSDocCommentRanges(node, sourceFile.text), function (comment) { return JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos); }); + if (jsDoc.length) + node.jsDoc = jsDoc; + return node; + } + function fixupParentReferences(rootNode) { + var stack = [rootNode]; + while (stack.length) { + var parent = stack.pop(); + bindParentToChildren(parent, gatherChildren(parent)); + } + return; + function gatherChildren(node) { + var children = []; + forEachChild(node, function (n) { children.unshift(n); }); + return children; + } + function bindParentToChildren(parent, children) { + for (var _i = 0, children_1 = children; _i < children_1.length; _i++) { + var child = children_1[_i]; + if (child.parent === parent) + continue; + child.parent = parent; + stack.push(child); + if (ts.hasJSDocNodes(child)) { + for (var _a = 0, _b = child.jsDoc; _a < _b.length; _a++) { + var jsDoc = _b[_a]; + jsDoc.parent = child; + stack.push(jsDoc); + } + } + } + } + } + Parser.fixupParentReferences = fixupParentReferences; + function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile) { + var sourceFile = new SourceFileConstructor(290, 0, sourceText.length); + nodeCount++; + sourceFile.text = sourceText; + sourceFile.bindDiagnostics = []; + sourceFile.bindSuggestionDiagnostics = undefined; + sourceFile.languageVersion = languageVersion; + sourceFile.fileName = ts.normalizePath(fileName); + sourceFile.languageVariant = getLanguageVariant(scriptKind); + sourceFile.isDeclarationFile = isDeclarationFile; + sourceFile.scriptKind = scriptKind; + return sourceFile; + } + function setContextFlag(val, flag) { + if (val) { + contextFlags |= flag; + } + else { + contextFlags &= ~flag; + } + } + function setDisallowInContext(val) { + setContextFlag(val, 4096); + } + function setYieldContext(val) { + setContextFlag(val, 8192); + } + function setDecoratorContext(val) { + setContextFlag(val, 16384); + } + function setAwaitContext(val) { + setContextFlag(val, 32768); + } + function doOutsideOfContext(context, func) { + var contextFlagsToClear = context & contextFlags; + if (contextFlagsToClear) { + setContextFlag(false, contextFlagsToClear); + var result = func(); + setContextFlag(true, contextFlagsToClear); + return result; + } + return func(); + } + function doInsideOfContext(context, func) { + var contextFlagsToSet = context & ~contextFlags; + if (contextFlagsToSet) { + setContextFlag(true, contextFlagsToSet); + var result = func(); + setContextFlag(false, contextFlagsToSet); + return result; + } + return func(); + } + function allowInAnd(func) { + return doOutsideOfContext(4096, func); + } + function disallowInAnd(func) { + return doInsideOfContext(4096, func); + } + function doInYieldContext(func) { + return doInsideOfContext(8192, func); + } + function doInDecoratorContext(func) { + return doInsideOfContext(16384, func); + } + function doInAwaitContext(func) { + return doInsideOfContext(32768, func); + } + function doOutsideOfAwaitContext(func) { + return doOutsideOfContext(32768, func); + } + function doInYieldAndAwaitContext(func) { + return doInsideOfContext(8192 | 32768, func); + } + function doOutsideOfYieldAndAwaitContext(func) { + return doOutsideOfContext(8192 | 32768, func); + } + function inContext(flags) { + return (contextFlags & flags) !== 0; + } + function inYieldContext() { + return inContext(8192); + } + function inDisallowInContext() { + return inContext(4096); + } + function inDecoratorContext() { + return inContext(16384); + } + function inAwaitContext() { + return inContext(32768); + } + function parseErrorAtCurrentToken(message, arg0) { + parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0); + } + function parseErrorAtPosition(start, length, message, arg0) { + var lastError = ts.lastOrUndefined(parseDiagnostics); + if (!lastError || start !== lastError.start) { + parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, start, length, message, arg0)); + } + parseErrorBeforeNextFinishedNode = true; + } + function parseErrorAt(start, end, message, arg0) { + parseErrorAtPosition(start, end - start, message, arg0); + } + function parseErrorAtRange(range, message, arg0) { + parseErrorAt(range.pos, range.end, message, arg0); + } + function scanError(message, length) { + parseErrorAtPosition(scanner.getTextPos(), length, message); + } + function getNodePos() { + return scanner.getStartPos(); + } + function token() { + return currentToken; + } + function nextTokenWithoutCheck() { + return currentToken = scanner.scan(); + } + function nextToken() { + if (ts.isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) { + parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), ts.Diagnostics.Keywords_cannot_contain_escape_characters); + } + return nextTokenWithoutCheck(); + } + function nextTokenJSDoc() { + return currentToken = scanner.scanJsDocToken(); + } + function reScanGreaterToken() { + return currentToken = scanner.reScanGreaterToken(); + } + function reScanSlashToken() { + return currentToken = scanner.reScanSlashToken(); + } + function reScanTemplateToken() { + return currentToken = scanner.reScanTemplateToken(); + } + function reScanLessThanToken() { + return currentToken = scanner.reScanLessThanToken(); + } + function scanJsxIdentifier() { + return currentToken = scanner.scanJsxIdentifier(); + } + function scanJsxText() { + return currentToken = scanner.scanJsxToken(); + } + function scanJsxAttributeValue() { + return currentToken = scanner.scanJsxAttributeValue(); + } + function speculationHelper(callback, isLookAhead) { + var saveToken = currentToken; + var saveParseDiagnosticsLength = parseDiagnostics.length; + var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + var saveContextFlags = contextFlags; + var result = isLookAhead + ? scanner.lookAhead(callback) + : scanner.tryScan(callback); + ts.Debug.assert(saveContextFlags === contextFlags); + if (!result || isLookAhead) { + currentToken = saveToken; + parseDiagnostics.length = saveParseDiagnosticsLength; + parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; + } + return result; + } + function lookAhead(callback) { + return speculationHelper(callback, true); + } + function tryParse(callback) { + return speculationHelper(callback, false); + } + function isIdentifier() { + if (token() === 75) { + return true; + } + if (token() === 121 && inYieldContext()) { + return false; + } + if (token() === 127 && inAwaitContext()) { + return false; + } + return token() > 112; + } + function parseExpected(kind, diagnosticMessage, shouldAdvance) { + if (shouldAdvance === void 0) { shouldAdvance = true; } + if (token() === kind) { + if (shouldAdvance) { + nextToken(); + } + return true; + } + if (diagnosticMessage) { + parseErrorAtCurrentToken(diagnosticMessage); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind)); + } + return false; + } + function parseExpectedJSDoc(kind) { + if (token() === kind) { + nextTokenJSDoc(); + return true; + } + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind)); + return false; + } + function parseOptional(t) { + if (token() === t) { + nextToken(); + return true; + } + return false; + } + function parseOptionalToken(t) { + if (token() === t) { + return parseTokenNode(); + } + return undefined; + } + function parseOptionalTokenJSDoc(t) { + if (token() === t) { + return parseTokenNodeJSDoc(); + } + return undefined; + } + function parseExpectedToken(t, diagnosticMessage, arg0) { + return parseOptionalToken(t) || + createMissingNode(t, false, diagnosticMessage || ts.Diagnostics._0_expected, arg0 || ts.tokenToString(t)); + } + function parseExpectedTokenJSDoc(t) { + return parseOptionalTokenJSDoc(t) || + createMissingNode(t, false, ts.Diagnostics._0_expected, ts.tokenToString(t)); + } + function parseTokenNode() { + var node = createNode(token()); + nextToken(); + return finishNode(node); + } + function parseTokenNodeJSDoc() { + var node = createNode(token()); + nextTokenJSDoc(); + return finishNode(node); + } + function canParseSemicolon() { + if (token() === 26) { + return true; + } + return token() === 19 || token() === 1 || scanner.hasPrecedingLineBreak(); + } + function parseSemicolon() { + if (canParseSemicolon()) { + if (token() === 26) { + nextToken(); + } + return true; + } + else { + return parseExpected(26); + } + } + function createNode(kind, pos) { + nodeCount++; + var p = pos >= 0 ? pos : scanner.getStartPos(); + return ts.isNodeKind(kind) || kind === 0 ? new NodeConstructor(kind, p, p) : + kind === 75 ? new IdentifierConstructor(kind, p, p) : + kind === 76 ? new PrivateIdentifierConstructor(kind, p, p) : + new TokenConstructor(kind, p, p); + } + function createNodeWithJSDoc(kind, pos) { + var node = createNode(kind, pos); + if (scanner.getTokenFlags() & 2) { + addJSDocComment(node); + } + return node; + } + function createNodeArray(elements, pos, end) { + var length = elements.length; + var array = (length >= 1 && length <= 4 ? elements.slice() : elements); + array.pos = pos; + array.end = end === undefined ? scanner.getStartPos() : end; + return array; + } + function finishNode(node, end) { + node.end = end === undefined ? scanner.getStartPos() : end; + if (contextFlags) { + node.flags |= contextFlags; + } + if (parseErrorBeforeNextFinishedNode) { + parseErrorBeforeNextFinishedNode = false; + node.flags |= 65536; + } + return node; + } + function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) { + if (reportAtCurrentPosition) { + parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0); + } + else if (diagnosticMessage) { + parseErrorAtCurrentToken(diagnosticMessage, arg0); + } + var result = createNode(kind); + if (kind === 75) { + result.escapedText = ""; + } + else if (ts.isLiteralKind(kind) || ts.isTemplateLiteralKind(kind)) { + result.text = ""; + } + return finishNode(result); + } + function internIdentifier(text) { + var identifier = identifiers.get(text); + if (identifier === undefined) { + identifiers.set(text, identifier = text); + } + return identifier; + } + function createIdentifier(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) { + identifierCount++; + if (isIdentifier) { + var node = createNode(75); + if (token() !== 75) { + node.originalKeywordKind = token(); + } + node.escapedText = ts.escapeLeadingUnderscores(internIdentifier(scanner.getTokenValue())); + nextTokenWithoutCheck(); + return finishNode(node); + } + if (token() === 76) { + parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + return createIdentifier(true); + } + var reportAtCurrentPosition = token() === 1; + var isReservedWord = scanner.isReservedWord(); + var msgArg = scanner.getTokenText(); + var defaultMessage = isReservedWord ? + ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here : + ts.Diagnostics.Identifier_expected; + return createMissingNode(75, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg); + } + function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) { + return createIdentifier(isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage); + } + function parseIdentifierName(diagnosticMessage) { + return createIdentifier(ts.tokenIsIdentifierOrKeyword(token()), diagnosticMessage); + } + function isLiteralPropertyName() { + return ts.tokenIsIdentifierOrKeyword(token()) || + token() === 10 || + token() === 8; + } + function parsePropertyNameWorker(allowComputedPropertyNames) { + if (token() === 10 || token() === 8) { + var node = parseLiteralNode(); + node.text = internIdentifier(node.text); + return node; + } + if (allowComputedPropertyNames && token() === 22) { + return parseComputedPropertyName(); + } + if (token() === 76) { + return parsePrivateIdentifier(); + } + return parseIdentifierName(); + } + function parsePropertyName() { + return parsePropertyNameWorker(true); + } + function parseComputedPropertyName() { + var node = createNode(154); + parseExpected(22); + node.expression = allowInAnd(parseExpression); + parseExpected(23); + return finishNode(node); + } + function internPrivateIdentifier(text) { + var privateIdentifier = privateIdentifiers.get(text); + if (privateIdentifier === undefined) { + privateIdentifiers.set(text, privateIdentifier = text); + } + return privateIdentifier; + } + function parsePrivateIdentifier() { + var node = createNode(76); + node.escapedText = ts.escapeLeadingUnderscores(internPrivateIdentifier(scanner.getTokenText())); + nextToken(); + return finishNode(node); + } + function parseContextualModifier(t) { + return token() === t && tryParse(nextTokenCanFollowModifier); + } + function nextTokenIsOnSameLineAndCanFollowModifier() { + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return false; + } + return canFollowModifier(); + } + function nextTokenCanFollowModifier() { + switch (token()) { + case 81: + return nextToken() === 88; + case 89: + nextToken(); + if (token() === 84) { + return lookAhead(nextTokenCanFollowDefaultKeyword); + } + if (token() === 145) { + return lookAhead(nextTokenCanFollowExportModifier); + } + return canFollowExportModifier(); + case 84: + return nextTokenCanFollowDefaultKeyword(); + case 120: + case 131: + case 142: + nextToken(); + return canFollowModifier(); + default: + return nextTokenIsOnSameLineAndCanFollowModifier(); + } + } + function canFollowExportModifier() { + return token() !== 41 + && token() !== 123 + && token() !== 18 + && canFollowModifier(); + } + function nextTokenCanFollowExportModifier() { + nextToken(); + return canFollowExportModifier(); + } + function parseAnyContextualModifier() { + return ts.isModifierKind(token()) && tryParse(nextTokenCanFollowModifier); + } + function canFollowModifier() { + return token() === 22 + || token() === 18 + || token() === 41 + || token() === 25 + || isLiteralPropertyName(); + } + function nextTokenCanFollowDefaultKeyword() { + nextToken(); + return token() === 80 || token() === 94 || + token() === 114 || + (token() === 122 && lookAhead(nextTokenIsClassKeywordOnSameLine)) || + (token() === 126 && lookAhead(nextTokenIsFunctionKeywordOnSameLine)); + } + function isListElement(parsingContext, inErrorRecovery) { + var node = currentNode(parsingContext); + if (node) { + return true; + } + switch (parsingContext) { + case 0: + case 1: + case 3: + return !(token() === 26 && inErrorRecovery) && isStartOfStatement(); + case 2: + return token() === 78 || token() === 84; + case 4: + return lookAhead(isTypeMemberStart); + case 5: + return lookAhead(isClassMemberStart) || (token() === 26 && !inErrorRecovery); + case 6: + return token() === 22 || isLiteralPropertyName(); + case 12: + switch (token()) { + case 22: + case 41: + case 25: + case 24: + return true; + default: + return isLiteralPropertyName(); + } + case 18: + return isLiteralPropertyName(); + case 9: + return token() === 22 || token() === 25 || isLiteralPropertyName(); + case 7: + if (token() === 18) { + return lookAhead(isValidHeritageClauseObjectLiteral); + } + if (!inErrorRecovery) { + return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword(); + } + else { + return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); + } + case 8: + return isIdentifierOrPrivateIdentifierOrPattern(); + case 10: + return token() === 27 || token() === 25 || isIdentifierOrPrivateIdentifierOrPattern(); + case 19: + return isIdentifier(); + case 15: + switch (token()) { + case 27: + case 24: + return true; + } + case 11: + return token() === 25 || isStartOfExpression(); + case 16: + return isStartOfParameter(false); + case 17: + return isStartOfParameter(true); + case 20: + case 21: + return token() === 27 || isStartOfType(); + case 22: + return isHeritageClause(); + case 23: + return ts.tokenIsIdentifierOrKeyword(token()); + case 13: + return ts.tokenIsIdentifierOrKeyword(token()) || token() === 18; + case 14: + return true; + } + return ts.Debug.fail("Non-exhaustive case in 'isListElement'."); + } + function isValidHeritageClauseObjectLiteral() { + ts.Debug.assert(token() === 18); + if (nextToken() === 19) { + var next = nextToken(); + return next === 27 || next === 18 || next === 90 || next === 113; + } + return true; + } + function nextTokenIsIdentifier() { + nextToken(); + return isIdentifier(); + } + function nextTokenIsIdentifierOrKeyword() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()); + } + function nextTokenIsIdentifierOrKeywordOrGreaterThan() { + nextToken(); + return ts.tokenIsIdentifierOrKeywordOrGreaterThan(token()); + } + function isHeritageClauseExtendsOrImplementsKeyword() { + if (token() === 113 || + token() === 90) { + return lookAhead(nextTokenIsStartOfExpression); + } + return false; + } + function nextTokenIsStartOfExpression() { + nextToken(); + return isStartOfExpression(); + } + function nextTokenIsStartOfType() { + nextToken(); + return isStartOfType(); + } + function isListTerminator(kind) { + if (token() === 1) { + return true; + } + switch (kind) { + case 1: + case 2: + case 4: + case 5: + case 6: + case 12: + case 9: + case 23: + return token() === 19; + case 3: + return token() === 19 || token() === 78 || token() === 84; + case 7: + return token() === 18 || token() === 90 || token() === 113; + case 8: + return isVariableDeclaratorListTerminator(); + case 19: + return token() === 31 || token() === 20 || token() === 18 || token() === 90 || token() === 113; + case 11: + return token() === 21 || token() === 26; + case 15: + case 21: + case 10: + return token() === 23; + case 17: + case 16: + case 18: + return token() === 21 || token() === 23; + case 20: + return token() !== 27; + case 22: + return token() === 18 || token() === 19; + case 13: + return token() === 31 || token() === 43; + case 14: + return token() === 29 && lookAhead(nextTokenIsSlash); + default: + return false; + } + } + function isVariableDeclaratorListTerminator() { + if (canParseSemicolon()) { + return true; + } + if (isInOrOfKeyword(token())) { + return true; + } + if (token() === 38) { + return true; + } + return false; + } + function isInSomeParsingContext() { + for (var kind = 0; kind < 24; kind++) { + if (parsingContext & (1 << kind)) { + if (isListElement(kind, true) || isListTerminator(kind)) { + return true; + } + } + } + return false; + } + function parseList(kind, parseElement) { + var saveParsingContext = parsingContext; + parsingContext |= 1 << kind; + var list = []; + var listPos = getNodePos(); + while (!isListTerminator(kind)) { + if (isListElement(kind, false)) { + var element = parseListElement(kind, parseElement); + list.push(element); + continue; + } + if (abortParsingListOrMoveToNextToken(kind)) { + break; + } + } + parsingContext = saveParsingContext; + return createNodeArray(list, listPos); + } + function parseListElement(parsingContext, parseElement) { + var node = currentNode(parsingContext); + if (node) { + return consumeNode(node); + } + return parseElement(); + } + function currentNode(parsingContext) { + if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode) { + return undefined; + } + var node = syntaxCursor.currentNode(scanner.getStartPos()); + if (ts.nodeIsMissing(node) || node.intersectsChange || ts.containsParseError(node)) { + return undefined; + } + var nodeContextFlags = node.flags & 25358336; + if (nodeContextFlags !== contextFlags) { + return undefined; + } + if (!canReuseNode(node, parsingContext)) { + return undefined; + } + if (node.jsDocCache) { + node.jsDocCache = undefined; + } + return node; + } + function consumeNode(node) { + scanner.setTextPos(node.end); + nextToken(); + return node; + } + function isReusableParsingContext(parsingContext) { + switch (parsingContext) { + case 5: + case 2: + case 0: + case 1: + case 3: + case 6: + case 4: + case 8: + case 17: + case 16: + return true; + } + return false; + } + function canReuseNode(node, parsingContext) { + switch (parsingContext) { + case 5: + return isReusableClassMember(node); + case 2: + return isReusableSwitchClause(node); + case 0: + case 1: + case 3: + return isReusableStatement(node); + case 6: + return isReusableEnumMember(node); + case 4: + return isReusableTypeMember(node); + case 8: + return isReusableVariableDeclaration(node); + case 17: + case 16: + return isReusableParameter(node); + } + return false; + } + function isReusableClassMember(node) { + if (node) { + switch (node.kind) { + case 162: + case 167: + case 163: + case 164: + case 159: + case 222: + return true; + case 161: + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 75 && + methodDeclaration.name.originalKeywordKind === 129; + return !nameIsConstructor; + } + } + return false; + } + function isReusableSwitchClause(node) { + if (node) { + switch (node.kind) { + case 277: + case 278: + return true; + } + } + return false; + } + function isReusableStatement(node) { + if (node) { + switch (node.kind) { + case 244: + case 225: + case 223: + case 227: + case 226: + case 239: + case 235: + case 237: + case 234: + case 233: + case 231: + case 232: + case 230: + case 229: + case 236: + case 224: + case 240: + case 238: + case 228: + case 241: + case 254: + case 253: + case 260: + case 259: + case 249: + case 245: + case 246: + case 248: + case 247: + return true; + } + } + return false; + } + function isReusableEnumMember(node) { + return node.kind === 284; + } + function isReusableTypeMember(node) { + if (node) { + switch (node.kind) { + case 166: + case 160: + case 167: + case 158: + case 165: + return true; + } + } + return false; + } + function isReusableVariableDeclaration(node) { + if (node.kind !== 242) { + return false; + } + var variableDeclarator = node; + return variableDeclarator.initializer === undefined; + } + function isReusableParameter(node) { + if (node.kind !== 156) { + return false; + } + var parameter = node; + return parameter.initializer === undefined; + } + function abortParsingListOrMoveToNextToken(kind) { + parseErrorAtCurrentToken(parsingContextErrors(kind)); + if (isInSomeParsingContext()) { + return true; + } + nextToken(); + return false; + } + function parsingContextErrors(context) { + switch (context) { + case 0: return ts.Diagnostics.Declaration_or_statement_expected; + case 1: return ts.Diagnostics.Declaration_or_statement_expected; + case 2: return ts.Diagnostics.case_or_default_expected; + case 3: return ts.Diagnostics.Statement_expected; + case 18: + case 4: return ts.Diagnostics.Property_or_signature_expected; + case 5: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; + case 6: return ts.Diagnostics.Enum_member_expected; + case 7: return ts.Diagnostics.Expression_expected; + case 8: return ts.Diagnostics.Variable_declaration_expected; + case 9: return ts.Diagnostics.Property_destructuring_pattern_expected; + case 10: return ts.Diagnostics.Array_element_destructuring_pattern_expected; + case 11: return ts.Diagnostics.Argument_expression_expected; + case 12: return ts.Diagnostics.Property_assignment_expected; + case 15: return ts.Diagnostics.Expression_or_comma_expected; + case 17: return ts.Diagnostics.Parameter_declaration_expected; + case 16: return ts.Diagnostics.Parameter_declaration_expected; + case 19: return ts.Diagnostics.Type_parameter_declaration_expected; + case 20: return ts.Diagnostics.Type_argument_expected; + case 21: return ts.Diagnostics.Type_expected; + case 22: return ts.Diagnostics.Unexpected_token_expected; + case 23: return ts.Diagnostics.Identifier_expected; + case 13: return ts.Diagnostics.Identifier_expected; + case 14: return ts.Diagnostics.Identifier_expected; + default: return undefined; + } + } + function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) { + var saveParsingContext = parsingContext; + parsingContext |= 1 << kind; + var list = []; + var listPos = getNodePos(); + var commaStart = -1; + while (true) { + if (isListElement(kind, false)) { + var startPos = scanner.getStartPos(); + list.push(parseListElement(kind, parseElement)); + commaStart = scanner.getTokenPos(); + if (parseOptional(27)) { + continue; + } + commaStart = -1; + if (isListTerminator(kind)) { + break; + } + parseExpected(27, getExpectedCommaDiagnostic(kind)); + if (considerSemicolonAsDelimiter && token() === 26 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + } + if (startPos === scanner.getStartPos()) { + nextToken(); + } + continue; + } + if (isListTerminator(kind)) { + break; + } + if (abortParsingListOrMoveToNextToken(kind)) { + break; + } + } + parsingContext = saveParsingContext; + var result = createNodeArray(list, listPos); + if (commaStart >= 0) { + result.hasTrailingComma = true; + } + return result; + } + function getExpectedCommaDiagnostic(kind) { + return kind === 6 ? ts.Diagnostics.An_enum_member_name_must_be_followed_by_a_or : undefined; + } + function createMissingList() { + var list = createNodeArray([], getNodePos()); + list.isMissingList = true; + return list; + } + function isMissingList(arr) { + return !!arr.isMissingList; + } + function parseBracketedList(kind, parseElement, open, close) { + if (parseExpected(open)) { + var result = parseDelimitedList(kind, parseElement); + parseExpected(close); + return result; + } + return createMissingList(); + } + function parseEntityName(allowReservedWords, diagnosticMessage) { + var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage); + var dotPos = scanner.getStartPos(); + while (parseOptional(24)) { + if (token() === 29) { + entity.jsdocDotPos = dotPos; + break; + } + dotPos = scanner.getStartPos(); + entity = createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, false)); + } + return entity; + } + function createQualifiedName(entity, name) { + var node = createNode(153, entity.pos); + node.left = entity; + node.right = name; + return finishNode(node); + } + function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) { + if (scanner.hasPrecedingLineBreak() && ts.tokenIsIdentifierOrKeyword(token())) { + var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + if (matchesPattern) { + return createMissingNode(75, true, ts.Diagnostics.Identifier_expected); + } + } + if (token() === 76) { + var node = parsePrivateIdentifier(); + return allowPrivateIdentifiers ? node : createMissingNode(75, true, ts.Diagnostics.Identifier_expected); + } + return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); + } + function parseTemplateExpression() { + var template = createNode(211); + template.head = parseTemplateHead(); + ts.Debug.assert(template.head.kind === 15, "Template head has wrong token kind"); + var list = []; + var listPos = getNodePos(); + do { + list.push(parseTemplateSpan()); + } while (ts.last(list).literal.kind === 16); + template.templateSpans = createNodeArray(list, listPos); + return finishNode(template); + } + function parseTemplateSpan() { + var span = createNode(221); + span.expression = allowInAnd(parseExpression); + var literal; + if (token() === 19) { + reScanTemplateToken(); + literal = parseTemplateMiddleOrTemplateTail(); + } + else { + literal = parseExpectedToken(17, ts.Diagnostics._0_expected, ts.tokenToString(19)); + } + span.literal = literal; + return finishNode(span); + } + function parseLiteralNode() { + return parseLiteralLikeNode(token()); + } + function parseTemplateHead() { + var fragment = parseLiteralLikeNode(token()); + ts.Debug.assert(fragment.kind === 15, "Template head has wrong token kind"); + return fragment; + } + function parseTemplateMiddleOrTemplateTail() { + var fragment = parseLiteralLikeNode(token()); + ts.Debug.assert(fragment.kind === 16 || fragment.kind === 17, "Template fragment has wrong token kind"); + return fragment; + } + function parseLiteralLikeNode(kind) { + var node = createNode(kind); + node.text = scanner.getTokenValue(); + switch (kind) { + case 14: + case 15: + case 16: + case 17: + var isLast = kind === 14 || kind === 17; + var tokenText = scanner.getTokenText(); + node.rawText = tokenText.substring(1, tokenText.length - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2)); + break; + } + if (scanner.hasExtendedUnicodeEscape()) { + node.hasExtendedUnicodeEscape = true; + } + if (scanner.isUnterminated()) { + node.isUnterminated = true; + } + if (node.kind === 8) { + node.numericLiteralFlags = scanner.getTokenFlags() & 1008; + } + nextToken(); + finishNode(node); + return node; + } + function parseTypeReference() { + var node = createNode(169); + node.typeName = parseEntityName(true, ts.Diagnostics.Type_expected); + if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) { + node.typeArguments = parseBracketedList(20, parseType, 29, 31); + } + return finishNode(node); + } + function typeHasArrowFunctionBlockingParseError(node) { + switch (node.kind) { + case 169: + return ts.nodeIsMissing(node.typeName); + case 170: + case 171: { + var _a = node, parameters = _a.parameters, type = _a.type; + return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type); + } + case 182: + return typeHasArrowFunctionBlockingParseError(node.type); + default: + return false; + } + } + function parseThisTypePredicate(lhs) { + nextToken(); + var node = createNode(168, lhs.pos); + node.parameterName = lhs; + node.type = parseType(); + return finishNode(node); + } + function parseThisTypeNode() { + var node = createNode(183); + nextToken(); + return finishNode(node); + } + function parseJSDocAllType(postFixEquals) { + var result = createNode(295); + if (postFixEquals) { + return createPostfixType(299, result); + } + else { + nextToken(); + } + return finishNode(result); + } + function parseJSDocNonNullableType() { + var result = createNode(298); + nextToken(); + result.type = parseNonArrayType(); + return finishNode(result); + } + function parseJSDocUnknownOrNullableType() { + var pos = scanner.getStartPos(); + nextToken(); + if (token() === 27 || + token() === 19 || + token() === 21 || + token() === 31 || + token() === 62 || + token() === 51) { + var result = createNode(296, pos); + return finishNode(result); + } + else { + var result = createNode(297, pos); + result.type = parseType(); + return finishNode(result); + } + } + function parseJSDocFunctionType() { + if (lookAhead(nextTokenIsOpenParen)) { + var result = createNodeWithJSDoc(300); + nextToken(); + fillSignature(58, 4 | 32, result); + return finishNode(result); + } + var node = createNode(169); + node.typeName = parseIdentifierName(); + return finishNode(node); + } + function parseJSDocParameter() { + var parameter = createNode(156); + if (token() === 104 || token() === 99) { + parameter.name = parseIdentifierName(); + parseExpected(58); + } + parameter.type = parseJSDocType(); + return finishNode(parameter); + } + function parseJSDocType() { + scanner.setInJSDocType(true); + var moduleSpecifier = parseOptionalToken(135); + if (moduleSpecifier) { + var moduleTag = createNode(302, moduleSpecifier.pos); + terminate: while (true) { + switch (token()) { + case 19: + case 1: + case 27: + case 5: + break terminate; + default: + nextTokenJSDoc(); + } + } + scanner.setInJSDocType(false); + return finishNode(moduleTag); + } + var dotdotdot = parseOptionalToken(25); + var type = parseTypeOrTypePredicate(); + scanner.setInJSDocType(false); + if (dotdotdot) { + var variadic = createNode(301, dotdotdot.pos); + variadic.type = type; + type = finishNode(variadic); + } + if (token() === 62) { + return createPostfixType(299, type); + } + return type; + } + function parseTypeQuery() { + var node = createNode(172); + parseExpected(108); + node.exprName = parseEntityName(true); + return finishNode(node); + } + function parseTypeParameter() { + var node = createNode(155); + node.name = parseIdentifier(); + if (parseOptional(90)) { + if (isStartOfType() || !isStartOfExpression()) { + node.constraint = parseType(); + } + else { + node.expression = parseUnaryExpressionOrHigher(); + } + } + if (parseOptional(62)) { + node.default = parseType(); + } + return finishNode(node); + } + function parseTypeParameters() { + if (token() === 29) { + return parseBracketedList(19, parseTypeParameter, 29, 31); + } + } + function parseParameterType() { + if (parseOptional(58)) { + return parseType(); + } + return undefined; + } + function isStartOfParameter(isJSDocParameter) { + return token() === 25 || + isIdentifierOrPrivateIdentifierOrPattern() || + ts.isModifierKind(token()) || + token() === 59 || + isStartOfType(!isJSDocParameter); + } + function parseParameter() { + var node = createNodeWithJSDoc(156); + if (token() === 104) { + node.name = createIdentifier(true); + node.type = parseParameterType(); + return finishNode(node); + } + node.decorators = parseDecorators(); + node.modifiers = parseModifiers(); + node.dotDotDotToken = parseOptionalToken(25); + node.name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_cannot_be_used_as_parameters); + if (ts.getFullWidth(node.name) === 0 && !node.modifiers && ts.isModifierKind(token())) { + nextToken(); + } + node.questionToken = parseOptionalToken(57); + node.type = parseParameterType(); + node.initializer = parseInitializer(); + return finishNode(node); + } + function fillSignature(returnToken, flags, signature) { + if (!(flags & 32)) { + signature.typeParameters = parseTypeParameters(); + } + var parametersParsedSuccessfully = parseParameterList(signature, flags); + if (shouldParseReturnType(returnToken, !!(flags & 4))) { + signature.type = parseTypeOrTypePredicate(); + if (typeHasArrowFunctionBlockingParseError(signature.type)) + return false; + } + return parametersParsedSuccessfully; + } + function shouldParseReturnType(returnToken, isType) { + if (returnToken === 38) { + parseExpected(returnToken); + return true; + } + else if (parseOptional(58)) { + return true; + } + else if (isType && token() === 38) { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(58)); + nextToken(); + return true; + } + return false; + } + function parseParameterList(signature, flags) { + if (!parseExpected(20)) { + signature.parameters = createMissingList(); + return false; + } + var savedYieldContext = inYieldContext(); + var savedAwaitContext = inAwaitContext(); + setYieldContext(!!(flags & 1)); + setAwaitContext(!!(flags & 2)); + signature.parameters = flags & 32 ? + parseDelimitedList(17, parseJSDocParameter) : + parseDelimitedList(16, parseParameter); + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + return parseExpected(21); + } + function parseTypeMemberSemicolon() { + if (parseOptional(27)) { + return; + } + parseSemicolon(); + } + function parseSignatureMember(kind) { + var node = createNodeWithJSDoc(kind); + if (kind === 166) { + parseExpected(99); + } + fillSignature(58, 4, node); + parseTypeMemberSemicolon(); + return finishNode(node); + } + function isIndexSignature() { + return token() === 22 && lookAhead(isUnambiguouslyIndexSignature); + } + function isUnambiguouslyIndexSignature() { + nextToken(); + if (token() === 25 || token() === 23) { + return true; + } + if (ts.isModifierKind(token())) { + nextToken(); + if (isIdentifier()) { + return true; + } + } + else if (!isIdentifier()) { + return false; + } + else { + nextToken(); + } + if (token() === 58 || token() === 27) { + return true; + } + if (token() !== 57) { + return false; + } + nextToken(); + return token() === 58 || token() === 27 || token() === 23; + } + function parseIndexSignatureDeclaration(node) { + node.kind = 167; + node.parameters = parseBracketedList(16, parseParameter, 22, 23); + node.type = parseTypeAnnotation(); + parseTypeMemberSemicolon(); + return finishNode(node); + } + function parsePropertyOrMethodSignature(node) { + node.name = parsePropertyName(); + node.questionToken = parseOptionalToken(57); + if (token() === 20 || token() === 29) { + node.kind = 160; + fillSignature(58, 4, node); + } + else { + node.kind = 158; + node.type = parseTypeAnnotation(); + if (token() === 62) { + node.initializer = parseInitializer(); + } + } + parseTypeMemberSemicolon(); + return finishNode(node); + } + function isTypeMemberStart() { + if (token() === 20 || token() === 29) { + return true; + } + var idToken = false; + while (ts.isModifierKind(token())) { + idToken = true; + nextToken(); + } + if (token() === 22) { + return true; + } + if (isLiteralPropertyName()) { + idToken = true; + nextToken(); + } + if (idToken) { + return token() === 20 || + token() === 29 || + token() === 57 || + token() === 58 || + token() === 27 || + canParseSemicolon(); + } + return false; + } + function parseTypeMember() { + if (token() === 20 || token() === 29) { + return parseSignatureMember(165); + } + if (token() === 99 && lookAhead(nextTokenIsOpenParenOrLessThan)) { + return parseSignatureMember(166); + } + var node = createNodeWithJSDoc(0); + node.modifiers = parseModifiers(); + if (isIndexSignature()) { + return parseIndexSignatureDeclaration(node); + } + return parsePropertyOrMethodSignature(node); + } + function nextTokenIsOpenParenOrLessThan() { + nextToken(); + return token() === 20 || token() === 29; + } + function nextTokenIsDot() { + return nextToken() === 24; + } + function nextTokenIsOpenParenOrLessThanOrDot() { + switch (nextToken()) { + case 20: + case 29: + case 24: + return true; + } + return false; + } + function parseTypeLiteral() { + var node = createNode(173); + node.members = parseObjectTypeMembers(); + return finishNode(node); + } + function parseObjectTypeMembers() { + var members; + if (parseExpected(18)) { + members = parseList(4, parseTypeMember); + parseExpected(19); + } + else { + members = createMissingList(); + } + return members; + } + function isStartOfMappedType() { + nextToken(); + if (token() === 39 || token() === 40) { + return nextToken() === 138; + } + if (token() === 138) { + nextToken(); + } + return token() === 22 && nextTokenIsIdentifier() && nextToken() === 97; + } + function parseMappedTypeParameter() { + var node = createNode(155); + node.name = parseIdentifier(); + parseExpected(97); + node.constraint = parseType(); + return finishNode(node); + } + function parseMappedType() { + var node = createNode(186); + parseExpected(18); + if (token() === 138 || token() === 39 || token() === 40) { + node.readonlyToken = parseTokenNode(); + if (node.readonlyToken.kind !== 138) { + parseExpectedToken(138); + } + } + parseExpected(22); + node.typeParameter = parseMappedTypeParameter(); + parseExpected(23); + if (token() === 57 || token() === 39 || token() === 40) { + node.questionToken = parseTokenNode(); + if (node.questionToken.kind !== 57) { + parseExpectedToken(57); + } + } + node.type = parseTypeAnnotation(); + parseSemicolon(); + parseExpected(19); + return finishNode(node); + } + function parseTupleElementType() { + var pos = getNodePos(); + if (parseOptional(25)) { + var node = createNode(177, pos); + node.type = parseType(); + return finishNode(node); + } + var type = parseType(); + if (!(contextFlags & 4194304) && type.kind === 297 && type.pos === type.type.pos) { + type.kind = 176; + } + return type; + } + function parseTupleType() { + var node = createNode(175); + node.elementTypes = parseBracketedList(21, parseTupleElementType, 22, 23); + return finishNode(node); + } + function parseParenthesizedType() { + var node = createNode(182); + parseExpected(20); + node.type = parseType(); + parseExpected(21); + return finishNode(node); + } + function parseFunctionOrConstructorType() { + var pos = getNodePos(); + var kind = parseOptional(99) ? 171 : 170; + var node = createNodeWithJSDoc(kind, pos); + fillSignature(38, 4, node); + return finishNode(node); + } + function parseKeywordAndNoDot() { + var node = parseTokenNode(); + return token() === 24 ? undefined : node; + } + function parseLiteralTypeNode(negative) { + var node = createNode(187); + var unaryMinusExpression; + if (negative) { + unaryMinusExpression = createNode(207); + unaryMinusExpression.operator = 40; + nextToken(); + } + var expression = token() === 106 || token() === 91 + ? parseTokenNode() + : parseLiteralLikeNode(token()); + if (negative) { + unaryMinusExpression.operand = expression; + finishNode(unaryMinusExpression); + expression = unaryMinusExpression; + } + node.literal = expression; + return finishNode(node); + } + function isStartOfTypeOfImportType() { + nextToken(); + return token() === 96; + } + function parseImportType() { + sourceFile.flags |= 1048576; + var node = createNode(188); + if (parseOptional(108)) { + node.isTypeOf = true; + } + parseExpected(96); + parseExpected(20); + node.argument = parseType(); + parseExpected(21); + if (parseOptional(24)) { + node.qualifier = parseEntityName(true, ts.Diagnostics.Type_expected); + } + if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) { + node.typeArguments = parseBracketedList(20, parseType, 29, 31); + } + return finishNode(node); + } + function nextTokenIsNumericOrBigIntLiteral() { + nextToken(); + return token() === 8 || token() === 9; + } + function parseNonArrayType() { + switch (token()) { + case 125: + case 148: + case 143: + case 140: + case 151: + case 144: + case 128: + case 146: + case 137: + case 141: + return tryParse(parseKeywordAndNoDot) || parseTypeReference(); + case 41: + return parseJSDocAllType(false); + case 65: + return parseJSDocAllType(true); + case 60: + scanner.reScanQuestionToken(); + case 57: + return parseJSDocUnknownOrNullableType(); + case 94: + return parseJSDocFunctionType(); + case 53: + return parseJSDocNonNullableType(); + case 14: + case 10: + case 8: + case 9: + case 106: + case 91: + return parseLiteralTypeNode(); + case 40: + return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(true) : parseTypeReference(); + case 110: + case 100: + return parseTokenNode(); + case 104: { + var thisKeyword = parseThisTypeNode(); + if (token() === 133 && !scanner.hasPrecedingLineBreak()) { + return parseThisTypePredicate(thisKeyword); + } + else { + return thisKeyword; + } + } + case 108: + return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery(); + case 18: + return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral(); + case 22: + return parseTupleType(); + case 20: + return parseParenthesizedType(); + case 96: + return parseImportType(); + case 124: + return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference(); + default: + return parseTypeReference(); + } + } + function isStartOfType(inStartOfParameter) { + switch (token()) { + case 125: + case 148: + case 143: + case 140: + case 151: + case 128: + case 138: + case 144: + case 147: + case 110: + case 146: + case 100: + case 104: + case 108: + case 137: + case 18: + case 22: + case 29: + case 51: + case 50: + case 99: + case 10: + case 8: + case 9: + case 106: + case 91: + case 141: + case 41: + case 57: + case 53: + case 25: + case 132: + case 96: + case 124: + return true; + case 94: + return !inStartOfParameter; + case 40: + return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral); + case 20: + return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType); + default: + return isIdentifier(); + } + } + function isStartOfParenthesizedOrFunctionType() { + nextToken(); + return token() === 21 || isStartOfParameter(false) || isStartOfType(); + } + function parsePostfixTypeOrHigher() { + var type = parseNonArrayType(); + while (!scanner.hasPrecedingLineBreak()) { + switch (token()) { + case 53: + type = createPostfixType(298, type); + break; + case 57: + if (!(contextFlags & 4194304) && lookAhead(nextTokenIsStartOfType)) { + return type; + } + type = createPostfixType(297, type); + break; + case 22: + parseExpected(22); + if (isStartOfType()) { + var node = createNode(185, type.pos); + node.objectType = type; + node.indexType = parseType(); + parseExpected(23); + type = finishNode(node); + } + else { + var node = createNode(174, type.pos); + node.elementType = type; + parseExpected(23); + type = finishNode(node); + } + break; + default: + return type; + } + } + return type; + } + function createPostfixType(kind, type) { + nextToken(); + var postfix = createNode(kind, type.pos); + postfix.type = type; + return finishNode(postfix); + } + function parseTypeOperator(operator) { + var node = createNode(184); + parseExpected(operator); + node.operator = operator; + node.type = parseTypeOperatorOrHigher(); + return finishNode(node); + } + function parseInferType() { + var node = createNode(181); + parseExpected(132); + var typeParameter = createNode(155); + typeParameter.name = parseIdentifier(); + node.typeParameter = finishNode(typeParameter); + return finishNode(node); + } + function parseTypeOperatorOrHigher() { + var operator = token(); + switch (operator) { + case 134: + case 147: + case 138: + return parseTypeOperator(operator); + case 132: + return parseInferType(); + } + return parsePostfixTypeOrHigher(); + } + function parseUnionOrIntersectionType(kind, parseConstituentType, operator) { + var start = scanner.getStartPos(); + var hasLeadingOperator = parseOptional(operator); + var type = parseConstituentType(); + if (token() === operator || hasLeadingOperator) { + var types = [type]; + while (parseOptional(operator)) { + types.push(parseConstituentType()); + } + var node = createNode(kind, start); + node.types = createNodeArray(types, start); + type = finishNode(node); + } + return type; + } + function parseIntersectionTypeOrHigher() { + return parseUnionOrIntersectionType(179, parseTypeOperatorOrHigher, 50); + } + function parseUnionTypeOrHigher() { + return parseUnionOrIntersectionType(178, parseIntersectionTypeOrHigher, 51); + } + function isStartOfFunctionType() { + if (token() === 29) { + return true; + } + return token() === 20 && lookAhead(isUnambiguouslyStartOfFunctionType); + } + function skipParameterStart() { + if (ts.isModifierKind(token())) { + parseModifiers(); + } + if (isIdentifier() || token() === 104) { + nextToken(); + return true; + } + if (token() === 22 || token() === 18) { + var previousErrorCount = parseDiagnostics.length; + parseIdentifierOrPattern(); + return previousErrorCount === parseDiagnostics.length; + } + return false; + } + function isUnambiguouslyStartOfFunctionType() { + nextToken(); + if (token() === 21 || token() === 25) { + return true; + } + if (skipParameterStart()) { + if (token() === 58 || token() === 27 || + token() === 57 || token() === 62) { + return true; + } + if (token() === 21) { + nextToken(); + if (token() === 38) { + return true; + } + } + } + return false; + } + function parseTypeOrTypePredicate() { + var typePredicateVariable = isIdentifier() && tryParse(parseTypePredicatePrefix); + var type = parseType(); + if (typePredicateVariable) { + var node = createNode(168, typePredicateVariable.pos); + node.assertsModifier = undefined; + node.parameterName = typePredicateVariable; + node.type = type; + return finishNode(node); + } + else { + return type; + } + } + function parseTypePredicatePrefix() { + var id = parseIdentifier(); + if (token() === 133 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + return id; + } + } + function parseAssertsTypePredicate() { + var node = createNode(168); + node.assertsModifier = parseExpectedToken(124); + node.parameterName = token() === 104 ? parseThisTypeNode() : parseIdentifier(); + node.type = parseOptional(133) ? parseType() : undefined; + return finishNode(node); + } + function parseType() { + return doOutsideOfContext(40960, parseTypeWorker); + } + function parseTypeWorker(noConditionalTypes) { + if (isStartOfFunctionType() || token() === 99) { + return parseFunctionOrConstructorType(); + } + var type = parseUnionTypeOrHigher(); + if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(90)) { + var node = createNode(180, type.pos); + node.checkType = type; + node.extendsType = parseTypeWorker(true); + parseExpected(57); + node.trueType = parseTypeWorker(); + parseExpected(58); + node.falseType = parseTypeWorker(); + return finishNode(node); + } + return type; + } + function parseTypeAnnotation() { + return parseOptional(58) ? parseType() : undefined; + } + function isStartOfLeftHandSideExpression() { + switch (token()) { + case 104: + case 102: + case 100: + case 106: + case 91: + case 8: + case 9: + case 10: + case 14: + case 15: + case 20: + case 22: + case 18: + case 94: + case 80: + case 99: + case 43: + case 67: + case 75: + return true; + case 96: + return lookAhead(nextTokenIsOpenParenOrLessThanOrDot); + default: + return isIdentifier(); + } + } + function isStartOfExpression() { + if (isStartOfLeftHandSideExpression()) { + return true; + } + switch (token()) { + case 39: + case 40: + case 54: + case 53: + case 85: + case 108: + case 110: + case 45: + case 46: + case 29: + case 127: + case 121: + case 76: + return true; + default: + if (isBinaryOperator()) { + return true; + } + return isIdentifier(); + } + } + function isStartOfExpressionStatement() { + return token() !== 18 && + token() !== 94 && + token() !== 80 && + token() !== 59 && + isStartOfExpression(); + } + function parseExpression() { + var saveDecoratorContext = inDecoratorContext(); + if (saveDecoratorContext) { + setDecoratorContext(false); + } + var expr = parseAssignmentExpressionOrHigher(); + var operatorToken; + while ((operatorToken = parseOptionalToken(27))) { + expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher()); + } + if (saveDecoratorContext) { + setDecoratorContext(true); + } + return expr; + } + function parseInitializer() { + return parseOptional(62) ? parseAssignmentExpressionOrHigher() : undefined; + } + function parseAssignmentExpressionOrHigher() { + if (isYieldExpression()) { + return parseYieldExpression(); + } + var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression(); + if (arrowExpression) { + return arrowExpression; + } + var expr = parseBinaryExpressionOrHigher(0); + if (expr.kind === 75 && token() === 38) { + return parseSimpleArrowFunctionExpression(expr); + } + if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) { + return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher()); + } + return parseConditionalExpressionRest(expr); + } + function isYieldExpression() { + if (token() === 121) { + if (inYieldContext()) { + return true; + } + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); + } + return false; + } + function nextTokenIsIdentifierOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && isIdentifier(); + } + function parseYieldExpression() { + var node = createNode(212); + nextToken(); + if (!scanner.hasPrecedingLineBreak() && + (token() === 41 || isStartOfExpression())) { + node.asteriskToken = parseOptionalToken(41); + node.expression = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + else { + return finishNode(node); + } + } + function parseSimpleArrowFunctionExpression(identifier, asyncModifier) { + ts.Debug.assert(token() === 38, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); + var node; + if (asyncModifier) { + node = createNode(202, asyncModifier.pos); + node.modifiers = asyncModifier; + } + else { + node = createNode(202, identifier.pos); + } + var parameter = createNode(156, identifier.pos); + parameter.name = identifier; + finishNode(parameter); + node.parameters = createNodeArray([parameter], parameter.pos, parameter.end); + node.equalsGreaterThanToken = parseExpectedToken(38); + node.body = parseArrowFunctionExpressionBody(!!asyncModifier); + return addJSDocComment(finishNode(node)); + } + function tryParseParenthesizedArrowFunctionExpression() { + var triState = isParenthesizedArrowFunctionExpression(); + if (triState === 0) { + return undefined; + } + var arrowFunction = triState === 1 + ? parseParenthesizedArrowFunctionExpressionHead(true) + : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead); + if (!arrowFunction) { + return undefined; + } + var isAsync = hasModifierOfKind(arrowFunction, 126); + var lastToken = token(); + arrowFunction.equalsGreaterThanToken = parseExpectedToken(38); + arrowFunction.body = (lastToken === 38 || lastToken === 18) + ? parseArrowFunctionExpressionBody(isAsync) + : parseIdentifier(); + return finishNode(arrowFunction); + } + function isParenthesizedArrowFunctionExpression() { + if (token() === 20 || token() === 29 || token() === 126) { + return lookAhead(isParenthesizedArrowFunctionExpressionWorker); + } + if (token() === 38) { + return 1; + } + return 0; + } + function isParenthesizedArrowFunctionExpressionWorker() { + if (token() === 126) { + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return 0; + } + if (token() !== 20 && token() !== 29) { + return 0; + } + } + var first = token(); + var second = nextToken(); + if (first === 20) { + if (second === 21) { + var third = nextToken(); + switch (third) { + case 38: + case 58: + case 18: + return 1; + default: + return 0; + } + } + if (second === 22 || second === 18) { + return 2; + } + if (second === 25) { + return 1; + } + if (ts.isModifierKind(second) && second !== 126 && lookAhead(nextTokenIsIdentifier)) { + return 1; + } + if (!isIdentifier() && second !== 104) { + return 0; + } + switch (nextToken()) { + case 58: + return 1; + case 57: + nextToken(); + if (token() === 58 || token() === 27 || token() === 62 || token() === 21) { + return 1; + } + return 0; + case 27: + case 62: + case 21: + return 2; + } + return 0; + } + else { + ts.Debug.assert(first === 29); + if (!isIdentifier()) { + return 0; + } + if (sourceFile.languageVariant === 1) { + var isArrowFunctionInJsx = lookAhead(function () { + var third = nextToken(); + if (third === 90) { + var fourth = nextToken(); + switch (fourth) { + case 62: + case 31: + return false; + default: + return true; + } + } + else if (third === 27) { + return true; + } + return false; + }); + if (isArrowFunctionInJsx) { + return 1; + } + return 0; + } + return 2; + } + } + function parsePossibleParenthesizedArrowFunctionExpressionHead() { + var tokenPos = scanner.getTokenPos(); + if (notParenthesizedArrow && notParenthesizedArrow.has(tokenPos.toString())) { + return undefined; + } + var result = parseParenthesizedArrowFunctionExpressionHead(false); + if (!result) { + (notParenthesizedArrow || (notParenthesizedArrow = ts.createMap())).set(tokenPos.toString(), true); + } + return result; + } + function tryParseAsyncSimpleArrowFunctionExpression() { + if (token() === 126) { + if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1) { + var asyncModifier = parseModifiersForArrowFunction(); + var expr = parseBinaryExpressionOrHigher(0); + return parseSimpleArrowFunctionExpression(expr, asyncModifier); + } + } + return undefined; + } + function isUnParenthesizedAsyncArrowFunctionWorker() { + if (token() === 126) { + nextToken(); + if (scanner.hasPrecedingLineBreak() || token() === 38) { + return 0; + } + var expr = parseBinaryExpressionOrHigher(0); + if (!scanner.hasPrecedingLineBreak() && expr.kind === 75 && token() === 38) { + return 1; + } + } + return 0; + } + function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { + var node = createNodeWithJSDoc(202); + node.modifiers = parseModifiersForArrowFunction(); + var isAsync = hasModifierOfKind(node, 126) ? 2 : 0; + if (!fillSignature(58, isAsync, node) && !allowAmbiguity) { + return undefined; + } + var hasJSDocFunctionType = node.type && ts.isJSDocFunctionType(node.type); + if (!allowAmbiguity && token() !== 38 && (hasJSDocFunctionType || token() !== 18)) { + return undefined; + } + return node; + } + function parseArrowFunctionExpressionBody(isAsync) { + if (token() === 18) { + return parseFunctionBlock(isAsync ? 2 : 0); + } + if (token() !== 26 && + token() !== 94 && + token() !== 80 && + isStartOfStatement() && + !isStartOfExpressionStatement()) { + return parseFunctionBlock(16 | (isAsync ? 2 : 0)); + } + return isAsync + ? doInAwaitContext(parseAssignmentExpressionOrHigher) + : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher); + } + function parseConditionalExpressionRest(leftOperand) { + var questionToken = parseOptionalToken(57); + if (!questionToken) { + return leftOperand; + } + var node = createNode(210, leftOperand.pos); + node.condition = leftOperand; + node.questionToken = questionToken; + node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); + node.colonToken = parseExpectedToken(58); + node.whenFalse = ts.nodeIsPresent(node.colonToken) + ? parseAssignmentExpressionOrHigher() + : createMissingNode(75, false, ts.Diagnostics._0_expected, ts.tokenToString(58)); + return finishNode(node); + } + function parseBinaryExpressionOrHigher(precedence) { + var leftOperand = parseUnaryExpressionOrHigher(); + return parseBinaryExpressionRest(precedence, leftOperand); + } + function isInOrOfKeyword(t) { + return t === 97 || t === 152; + } + function parseBinaryExpressionRest(precedence, leftOperand) { + while (true) { + reScanGreaterToken(); + var newPrecedence = ts.getBinaryOperatorPrecedence(token()); + var consumeCurrentOperator = token() === 42 ? + newPrecedence >= precedence : + newPrecedence > precedence; + if (!consumeCurrentOperator) { + break; + } + if (token() === 97 && inDisallowInContext()) { + break; + } + if (token() === 123) { + if (scanner.hasPrecedingLineBreak()) { + break; + } + else { + nextToken(); + leftOperand = makeAsExpression(leftOperand, parseType()); + } + } + else { + leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence)); + } + } + return leftOperand; + } + function isBinaryOperator() { + if (inDisallowInContext() && token() === 97) { + return false; + } + return ts.getBinaryOperatorPrecedence(token()) > 0; + } + function makeBinaryExpression(left, operatorToken, right) { + var node = createNode(209, left.pos); + node.left = left; + node.operatorToken = operatorToken; + node.right = right; + return finishNode(node); + } + function makeAsExpression(left, right) { + var node = createNode(217, left.pos); + node.expression = left; + node.type = right; + return finishNode(node); + } + function parsePrefixUnaryExpression() { + var node = createNode(207); + node.operator = token(); + nextToken(); + node.operand = parseSimpleUnaryExpression(); + return finishNode(node); + } + function parseDeleteExpression() { + var node = createNode(203); + nextToken(); + node.expression = parseSimpleUnaryExpression(); + return finishNode(node); + } + function parseTypeOfExpression() { + var node = createNode(204); + nextToken(); + node.expression = parseSimpleUnaryExpression(); + return finishNode(node); + } + function parseVoidExpression() { + var node = createNode(205); + nextToken(); + node.expression = parseSimpleUnaryExpression(); + return finishNode(node); + } + function isAwaitExpression() { + if (token() === 127) { + if (inAwaitContext()) { + return true; + } + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); + } + return false; + } + function parseAwaitExpression() { + var node = createNode(206); + nextToken(); + node.expression = parseSimpleUnaryExpression(); + return finishNode(node); + } + function parseUnaryExpressionOrHigher() { + if (isUpdateExpression()) { + var updateExpression = parseUpdateExpression(); + return token() === 42 ? + parseBinaryExpressionRest(ts.getBinaryOperatorPrecedence(token()), updateExpression) : + updateExpression; + } + var unaryOperator = token(); + var simpleUnaryExpression = parseSimpleUnaryExpression(); + if (token() === 42) { + var pos = ts.skipTrivia(sourceText, simpleUnaryExpression.pos); + var end = simpleUnaryExpression.end; + if (simpleUnaryExpression.kind === 199) { + parseErrorAt(pos, end, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses); + } + else { + parseErrorAt(pos, end, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator)); + } + } + return simpleUnaryExpression; + } + function parseSimpleUnaryExpression() { + switch (token()) { + case 39: + case 40: + case 54: + case 53: + return parsePrefixUnaryExpression(); + case 85: + return parseDeleteExpression(); + case 108: + return parseTypeOfExpression(); + case 110: + return parseVoidExpression(); + case 29: + return parseTypeAssertion(); + case 127: + if (isAwaitExpression()) { + return parseAwaitExpression(); + } + default: + return parseUpdateExpression(); + } + } + function isUpdateExpression() { + switch (token()) { + case 39: + case 40: + case 54: + case 53: + case 85: + case 108: + case 110: + case 127: + return false; + case 29: + if (sourceFile.languageVariant !== 1) { + return false; + } + default: + return true; + } + } + function parseUpdateExpression() { + if (token() === 45 || token() === 46) { + var node = createNode(207); + node.operator = token(); + nextToken(); + node.operand = parseLeftHandSideExpressionOrHigher(); + return finishNode(node); + } + else if (sourceFile.languageVariant === 1 && token() === 29 && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) { + return parseJsxElementOrSelfClosingElementOrFragment(true); + } + var expression = parseLeftHandSideExpressionOrHigher(); + ts.Debug.assert(ts.isLeftHandSideExpression(expression)); + if ((token() === 45 || token() === 46) && !scanner.hasPrecedingLineBreak()) { + var node = createNode(208, expression.pos); + node.operand = expression; + node.operator = token(); + nextToken(); + return finishNode(node); + } + return expression; + } + function parseLeftHandSideExpressionOrHigher() { + var expression; + if (token() === 96) { + if (lookAhead(nextTokenIsOpenParenOrLessThan)) { + sourceFile.flags |= 1048576; + expression = parseTokenNode(); + } + else if (lookAhead(nextTokenIsDot)) { + var fullStart = scanner.getStartPos(); + nextToken(); + nextToken(); + var node = createNode(219, fullStart); + node.keywordToken = 96; + node.name = parseIdentifierName(); + expression = finishNode(node); + sourceFile.flags |= 2097152; + } + else { + expression = parseMemberExpressionOrHigher(); + } + } + else { + expression = token() === 102 ? parseSuperExpression() : parseMemberExpressionOrHigher(); + } + return parseCallExpressionRest(expression); + } + function parseMemberExpressionOrHigher() { + var expression = parsePrimaryExpression(); + return parseMemberExpressionRest(expression, true); + } + function parseSuperExpression() { + var expression = parseTokenNode(); + if (token() === 29) { + var startPos = getNodePos(); + var typeArguments = tryParse(parseTypeArgumentsInExpression); + if (typeArguments !== undefined) { + parseErrorAt(startPos, getNodePos(), ts.Diagnostics.super_may_not_use_type_arguments); + } + } + if (token() === 20 || token() === 24 || token() === 22) { + return expression; + } + var node = createNode(194, expression.pos); + node.expression = expression; + parseExpectedToken(24, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); + node.name = parseRightSideOfDot(true, true); + return finishNode(node); + } + function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext) { + var opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext); + var result; + if (opening.kind === 268) { + var node = createNode(266, opening.pos); + node.openingElement = opening; + node.children = parseJsxChildren(node.openingElement); + node.closingElement = parseJsxClosingElement(inExpressionContext); + if (!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) { + parseErrorAtRange(node.closingElement, ts.Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, ts.getTextOfNodeFromSourceText(sourceText, node.openingElement.tagName)); + } + result = finishNode(node); + } + else if (opening.kind === 271) { + var node = createNode(270, opening.pos); + node.openingFragment = opening; + node.children = parseJsxChildren(node.openingFragment); + node.closingFragment = parseJsxClosingFragment(inExpressionContext); + result = finishNode(node); + } + else { + ts.Debug.assert(opening.kind === 267); + result = opening; + } + if (inExpressionContext && token() === 29) { + var invalidElement = tryParse(function () { return parseJsxElementOrSelfClosingElementOrFragment(true); }); + if (invalidElement) { + parseErrorAtCurrentToken(ts.Diagnostics.JSX_expressions_must_have_one_parent_element); + var badNode = createNode(209, result.pos); + badNode.end = invalidElement.end; + badNode.left = result; + badNode.right = invalidElement; + badNode.operatorToken = createMissingNode(27, false); + badNode.operatorToken.pos = badNode.operatorToken.end = badNode.right.pos; + return badNode; + } + } + return result; + } + function parseJsxText() { + var node = createNode(11); + node.text = scanner.getTokenValue(); + node.containsOnlyTriviaWhiteSpaces = currentToken === 12; + currentToken = scanner.scanJsxToken(); + return finishNode(node); + } + function parseJsxChild(openingTag, token) { + switch (token) { + case 1: + if (ts.isJsxOpeningFragment(openingTag)) { + parseErrorAtRange(openingTag, ts.Diagnostics.JSX_fragment_has_no_corresponding_closing_tag); + } + else { + parseErrorAtRange(openingTag.tagName, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, openingTag.tagName)); + } + return undefined; + case 30: + case 7: + return undefined; + case 11: + case 12: + return parseJsxText(); + case 18: + return parseJsxExpression(false); + case 29: + return parseJsxElementOrSelfClosingElementOrFragment(false); + default: + return ts.Debug.assertNever(token); + } + } + function parseJsxChildren(openingTag) { + var list = []; + var listPos = getNodePos(); + var saveParsingContext = parsingContext; + parsingContext |= 1 << 14; + while (true) { + var child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken()); + if (!child) + break; + list.push(child); + } + parsingContext = saveParsingContext; + return createNodeArray(list, listPos); + } + function parseJsxAttributes() { + var jsxAttributes = createNode(274); + jsxAttributes.properties = parseList(13, parseJsxAttribute); + return finishNode(jsxAttributes); + } + function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) { + var fullStart = scanner.getStartPos(); + parseExpected(29); + if (token() === 31) { + var node_1 = createNode(271, fullStart); + scanJsxText(); + return finishNode(node_1); + } + var tagName = parseJsxElementName(); + var typeArguments = tryParseTypeArguments(); + var attributes = parseJsxAttributes(); + var node; + if (token() === 31) { + node = createNode(268, fullStart); + scanJsxText(); + } + else { + parseExpected(43); + if (inExpressionContext) { + parseExpected(31); + } + else { + parseExpected(31, undefined, false); + scanJsxText(); + } + node = createNode(267, fullStart); + } + node.tagName = tagName; + node.typeArguments = typeArguments; + node.attributes = attributes; + return finishNode(node); + } + function parseJsxElementName() { + scanJsxIdentifier(); + var expression = token() === 104 ? + parseTokenNode() : parseIdentifierName(); + while (parseOptional(24)) { + var propertyAccess = createNode(194, expression.pos); + propertyAccess.expression = expression; + propertyAccess.name = parseRightSideOfDot(true, false); + expression = finishNode(propertyAccess); + } + return expression; + } + function parseJsxExpression(inExpressionContext) { + var node = createNode(276); + if (!parseExpected(18)) { + return undefined; + } + if (token() !== 19) { + node.dotDotDotToken = parseOptionalToken(25); + node.expression = parseExpression(); + } + if (inExpressionContext) { + parseExpected(19); + } + else { + if (parseExpected(19, undefined, false)) { + scanJsxText(); + } + } + return finishNode(node); + } + function parseJsxAttribute() { + if (token() === 18) { + return parseJsxSpreadAttribute(); + } + scanJsxIdentifier(); + var node = createNode(273); + node.name = parseIdentifierName(); + if (token() === 62) { + switch (scanJsxAttributeValue()) { + case 10: + node.initializer = parseLiteralNode(); + break; + default: + node.initializer = parseJsxExpression(true); + break; + } + } + return finishNode(node); + } + function parseJsxSpreadAttribute() { + var node = createNode(275); + parseExpected(18); + parseExpected(25); + node.expression = parseExpression(); + parseExpected(19); + return finishNode(node); + } + function parseJsxClosingElement(inExpressionContext) { + var node = createNode(269); + parseExpected(30); + node.tagName = parseJsxElementName(); + if (inExpressionContext) { + parseExpected(31); + } + else { + parseExpected(31, undefined, false); + scanJsxText(); + } + return finishNode(node); + } + function parseJsxClosingFragment(inExpressionContext) { + var node = createNode(272); + parseExpected(30); + if (ts.tokenIsIdentifierOrKeyword(token())) { + parseErrorAtRange(parseJsxElementName(), ts.Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment); + } + if (inExpressionContext) { + parseExpected(31); + } + else { + parseExpected(31, undefined, false); + scanJsxText(); + } + return finishNode(node); + } + function parseTypeAssertion() { + var node = createNode(199); + parseExpected(29); + node.type = parseType(); + parseExpected(31); + node.expression = parseSimpleUnaryExpression(); + return finishNode(node); + } + function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()) + || token() === 22 + || isTemplateStartOfTaggedTemplate(); + } + function isStartOfOptionalPropertyOrElementAccessChain() { + return token() === 28 + && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate); + } + function parsePropertyAccessExpressionRest(expression, questionDotToken) { + var propertyAccess = createNode(194, expression.pos); + propertyAccess.expression = expression; + propertyAccess.questionDotToken = questionDotToken; + propertyAccess.name = parseRightSideOfDot(true, true); + if (questionDotToken || expression.flags & 32) { + propertyAccess.flags |= 32; + if (ts.isPrivateIdentifier(propertyAccess.name)) { + parseErrorAtRange(propertyAccess.name, ts.Diagnostics.An_optional_chain_cannot_contain_private_identifiers); + } + } + return finishNode(propertyAccess); + } + function parseElementAccessExpressionRest(expression, questionDotToken) { + var indexedAccess = createNode(195, expression.pos); + indexedAccess.expression = expression; + indexedAccess.questionDotToken = questionDotToken; + if (token() === 23) { + indexedAccess.argumentExpression = createMissingNode(75, true, ts.Diagnostics.An_element_access_expression_should_take_an_argument); + } + else { + var argument = allowInAnd(parseExpression); + if (ts.isStringOrNumericLiteralLike(argument)) { + argument.text = internIdentifier(argument.text); + } + indexedAccess.argumentExpression = argument; + } + parseExpected(23); + if (questionDotToken || expression.flags & 32) { + indexedAccess.flags |= 32; + } + return finishNode(indexedAccess); + } + function parseMemberExpressionRest(expression, allowOptionalChain) { + while (true) { + var questionDotToken = void 0; + var isPropertyAccess = false; + if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) { + questionDotToken = parseExpectedToken(28); + isPropertyAccess = ts.tokenIsIdentifierOrKeyword(token()); + } + else { + isPropertyAccess = parseOptional(24); + } + if (isPropertyAccess) { + expression = parsePropertyAccessExpressionRest(expression, questionDotToken); + continue; + } + if (!questionDotToken && token() === 53 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + var nonNullExpression = createNode(218, expression.pos); + nonNullExpression.expression = expression; + expression = finishNode(nonNullExpression); + continue; + } + if ((questionDotToken || !inDecoratorContext()) && parseOptional(22)) { + expression = parseElementAccessExpressionRest(expression, questionDotToken); + continue; + } + if (isTemplateStartOfTaggedTemplate()) { + expression = parseTaggedTemplateRest(expression, questionDotToken, undefined); + continue; + } + return expression; + } + } + function isTemplateStartOfTaggedTemplate() { + return token() === 14 || token() === 15; + } + function parseTaggedTemplateRest(tag, questionDotToken, typeArguments) { + var tagExpression = createNode(198, tag.pos); + tagExpression.tag = tag; + tagExpression.questionDotToken = questionDotToken; + tagExpression.typeArguments = typeArguments; + tagExpression.template = token() === 14 + ? parseLiteralNode() + : parseTemplateExpression(); + if (questionDotToken || tag.flags & 32) { + tagExpression.flags |= 32; + } + return finishNode(tagExpression); + } + function parseCallExpressionRest(expression) { + while (true) { + expression = parseMemberExpressionRest(expression, true); + var questionDotToken = parseOptionalToken(28); + if (token() === 29 || token() === 47) { + var typeArguments = tryParse(parseTypeArgumentsInExpression); + if (typeArguments) { + if (isTemplateStartOfTaggedTemplate()) { + expression = parseTaggedTemplateRest(expression, questionDotToken, typeArguments); + continue; + } + var callExpr = createNode(196, expression.pos); + callExpr.expression = expression; + callExpr.questionDotToken = questionDotToken; + callExpr.typeArguments = typeArguments; + callExpr.arguments = parseArgumentList(); + if (questionDotToken || expression.flags & 32) { + callExpr.flags |= 32; + } + expression = finishNode(callExpr); + continue; + } + } + else if (token() === 20) { + var callExpr = createNode(196, expression.pos); + callExpr.expression = expression; + callExpr.questionDotToken = questionDotToken; + callExpr.arguments = parseArgumentList(); + if (questionDotToken || expression.flags & 32) { + callExpr.flags |= 32; + } + expression = finishNode(callExpr); + continue; + } + if (questionDotToken) { + var propertyAccess = createNode(194, expression.pos); + propertyAccess.expression = expression; + propertyAccess.questionDotToken = questionDotToken; + propertyAccess.name = createMissingNode(75, false, ts.Diagnostics.Identifier_expected); + propertyAccess.flags |= 32; + expression = finishNode(propertyAccess); + } + break; + } + return expression; + } + function parseArgumentList() { + parseExpected(20); + var result = parseDelimitedList(11, parseArgumentExpression); + parseExpected(21); + return result; + } + function parseTypeArgumentsInExpression() { + if (reScanLessThanToken() !== 29) { + return undefined; + } + nextToken(); + var typeArguments = parseDelimitedList(20, parseType); + if (!parseExpected(31)) { + return undefined; + } + return typeArguments && canFollowTypeArgumentsInExpression() + ? typeArguments + : undefined; + } + function canFollowTypeArgumentsInExpression() { + switch (token()) { + case 20: + case 14: + case 15: + case 24: + case 21: + case 23: + case 58: + case 26: + case 57: + case 34: + case 36: + case 35: + case 37: + case 55: + case 56: + case 60: + case 52: + case 50: + case 51: + case 19: + case 1: + return true; + case 27: + case 18: + default: + return false; + } + } + function parsePrimaryExpression() { + switch (token()) { + case 8: + case 9: + case 10: + case 14: + return parseLiteralNode(); + case 104: + case 102: + case 100: + case 106: + case 91: + return parseTokenNode(); + case 20: + return parseParenthesizedExpression(); + case 22: + return parseArrayLiteralExpression(); + case 18: + return parseObjectLiteralExpression(); + case 126: + if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) { + break; + } + return parseFunctionExpression(); + case 80: + return parseClassExpression(); + case 94: + return parseFunctionExpression(); + case 99: + return parseNewExpressionOrNewDotTarget(); + case 43: + case 67: + if (reScanSlashToken() === 13) { + return parseLiteralNode(); + } + break; + case 15: + return parseTemplateExpression(); + } + return parseIdentifier(ts.Diagnostics.Expression_expected); + } + function parseParenthesizedExpression() { + var node = createNodeWithJSDoc(200); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + return finishNode(node); + } + function parseSpreadElement() { + var node = createNode(213); + parseExpected(25); + node.expression = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + function parseArgumentOrArrayLiteralElement() { + return token() === 25 ? parseSpreadElement() : + token() === 27 ? createNode(215) : + parseAssignmentExpressionOrHigher(); + } + function parseArgumentExpression() { + return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); + } + function parseArrayLiteralExpression() { + var node = createNode(192); + parseExpected(22); + if (scanner.hasPrecedingLineBreak()) { + node.multiLine = true; + } + node.elements = parseDelimitedList(15, parseArgumentOrArrayLiteralElement); + parseExpected(23); + return finishNode(node); + } + function parseObjectLiteralElement() { + var node = createNodeWithJSDoc(0); + if (parseOptionalToken(25)) { + node.kind = 283; + node.expression = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + node.decorators = parseDecorators(); + node.modifiers = parseModifiers(); + if (parseContextualModifier(131)) { + return parseAccessorDeclaration(node, 163); + } + if (parseContextualModifier(142)) { + return parseAccessorDeclaration(node, 164); + } + var asteriskToken = parseOptionalToken(41); + var tokenIsIdentifier = isIdentifier(); + node.name = parsePropertyName(); + node.questionToken = parseOptionalToken(57); + node.exclamationToken = parseOptionalToken(53); + if (asteriskToken || token() === 20 || token() === 29) { + return parseMethodDeclaration(node, asteriskToken); + } + var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58); + if (isShorthandPropertyAssignment) { + node.kind = 282; + var equalsToken = parseOptionalToken(62); + if (equalsToken) { + node.equalsToken = equalsToken; + node.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher); + } + } + else { + node.kind = 281; + parseExpected(58); + node.initializer = allowInAnd(parseAssignmentExpressionOrHigher); + } + return finishNode(node); + } + function parseObjectLiteralExpression() { + var node = createNode(193); + parseExpected(18); + if (scanner.hasPrecedingLineBreak()) { + node.multiLine = true; + } + node.properties = parseDelimitedList(12, parseObjectLiteralElement, true); + parseExpected(19); + return finishNode(node); + } + function parseFunctionExpression() { + var saveDecoratorContext = inDecoratorContext(); + if (saveDecoratorContext) { + setDecoratorContext(false); + } + var node = createNodeWithJSDoc(201); + node.modifiers = parseModifiers(); + parseExpected(94); + node.asteriskToken = parseOptionalToken(41); + var isGenerator = node.asteriskToken ? 1 : 0; + var isAsync = hasModifierOfKind(node, 126) ? 2 : 0; + node.name = + isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) : + isGenerator ? doInYieldContext(parseOptionalIdentifier) : + isAsync ? doInAwaitContext(parseOptionalIdentifier) : + parseOptionalIdentifier(); + fillSignature(58, isGenerator | isAsync, node); + node.body = parseFunctionBlock(isGenerator | isAsync); + if (saveDecoratorContext) { + setDecoratorContext(true); + } + return finishNode(node); + } + function parseOptionalIdentifier() { + return isIdentifier() ? parseIdentifier() : undefined; + } + function parseNewExpressionOrNewDotTarget() { + var fullStart = scanner.getStartPos(); + parseExpected(99); + if (parseOptional(24)) { + var node_2 = createNode(219, fullStart); + node_2.keywordToken = 99; + node_2.name = parseIdentifierName(); + return finishNode(node_2); + } + var expression = parsePrimaryExpression(); + var typeArguments; + while (true) { + expression = parseMemberExpressionRest(expression, false); + typeArguments = tryParse(parseTypeArgumentsInExpression); + if (isTemplateStartOfTaggedTemplate()) { + ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'"); + expression = parseTaggedTemplateRest(expression, undefined, typeArguments); + typeArguments = undefined; + } + break; + } + var node = createNode(197, fullStart); + node.expression = expression; + node.typeArguments = typeArguments; + if (node.typeArguments || token() === 20) { + node.arguments = parseArgumentList(); + } + return finishNode(node); + } + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var node = createNode(223); + var openBracePosition = scanner.getTokenPos(); + if (parseExpected(18, diagnosticMessage) || ignoreMissingOpenBrace) { + if (scanner.hasPrecedingLineBreak()) { + node.multiLine = true; + } + node.statements = parseList(1, parseStatement); + if (!parseExpected(19)) { + var lastError = ts.lastOrUndefined(parseDiagnostics); + if (lastError && lastError.code === ts.Diagnostics._0_expected.code) { + ts.addRelatedInfo(lastError, ts.createFileDiagnostic(sourceFile, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here)); + } + } + } + else { + node.statements = createMissingList(); + } + return finishNode(node); + } + function parseFunctionBlock(flags, diagnosticMessage) { + var savedYieldContext = inYieldContext(); + setYieldContext(!!(flags & 1)); + var savedAwaitContext = inAwaitContext(); + setAwaitContext(!!(flags & 2)); + var saveDecoratorContext = inDecoratorContext(); + if (saveDecoratorContext) { + setDecoratorContext(false); + } + var block = parseBlock(!!(flags & 16), diagnosticMessage); + if (saveDecoratorContext) { + setDecoratorContext(true); + } + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + return block; + } + function parseEmptyStatement() { + var node = createNode(224); + parseExpected(26); + return finishNode(node); + } + function parseIfStatement() { + var node = createNode(227); + parseExpected(95); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + node.thenStatement = parseStatement(); + node.elseStatement = parseOptional(87) ? parseStatement() : undefined; + return finishNode(node); + } + function parseDoStatement() { + var node = createNode(228); + parseExpected(86); + node.statement = parseStatement(); + parseExpected(111); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + parseOptional(26); + return finishNode(node); + } + function parseWhileStatement() { + var node = createNode(229); + parseExpected(111); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + node.statement = parseStatement(); + return finishNode(node); + } + function parseForOrForInOrForOfStatement() { + var pos = getNodePos(); + parseExpected(93); + var awaitToken = parseOptionalToken(127); + parseExpected(20); + var initializer; + if (token() !== 26) { + if (token() === 109 || token() === 115 || token() === 81) { + initializer = parseVariableDeclarationList(true); + } + else { + initializer = disallowInAnd(parseExpression); + } + } + var forOrForInOrForOfStatement; + if (awaitToken ? parseExpected(152) : parseOptional(152)) { + var forOfStatement = createNode(232, pos); + forOfStatement.awaitModifier = awaitToken; + forOfStatement.initializer = initializer; + forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); + parseExpected(21); + forOrForInOrForOfStatement = forOfStatement; + } + else if (parseOptional(97)) { + var forInStatement = createNode(231, pos); + forInStatement.initializer = initializer; + forInStatement.expression = allowInAnd(parseExpression); + parseExpected(21); + forOrForInOrForOfStatement = forInStatement; + } + else { + var forStatement = createNode(230, pos); + forStatement.initializer = initializer; + parseExpected(26); + if (token() !== 26 && token() !== 21) { + forStatement.condition = allowInAnd(parseExpression); + } + parseExpected(26); + if (token() !== 21) { + forStatement.incrementor = allowInAnd(parseExpression); + } + parseExpected(21); + forOrForInOrForOfStatement = forStatement; + } + forOrForInOrForOfStatement.statement = parseStatement(); + return finishNode(forOrForInOrForOfStatement); + } + function parseBreakOrContinueStatement(kind) { + var node = createNode(kind); + parseExpected(kind === 234 ? 77 : 82); + if (!canParseSemicolon()) { + node.label = parseIdentifier(); + } + parseSemicolon(); + return finishNode(node); + } + function parseReturnStatement() { + var node = createNode(235); + parseExpected(101); + if (!canParseSemicolon()) { + node.expression = allowInAnd(parseExpression); + } + parseSemicolon(); + return finishNode(node); + } + function parseWithStatement() { + var node = createNode(236); + parseExpected(112); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + node.statement = doInsideOfContext(16777216, parseStatement); + return finishNode(node); + } + function parseCaseClause() { + var node = createNode(277); + parseExpected(78); + node.expression = allowInAnd(parseExpression); + parseExpected(58); + node.statements = parseList(3, parseStatement); + return finishNode(node); + } + function parseDefaultClause() { + var node = createNode(278); + parseExpected(84); + parseExpected(58); + node.statements = parseList(3, parseStatement); + return finishNode(node); + } + function parseCaseOrDefaultClause() { + return token() === 78 ? parseCaseClause() : parseDefaultClause(); + } + function parseSwitchStatement() { + var node = createNode(237); + parseExpected(103); + parseExpected(20); + node.expression = allowInAnd(parseExpression); + parseExpected(21); + var caseBlock = createNode(251); + parseExpected(18); + caseBlock.clauses = parseList(2, parseCaseOrDefaultClause); + parseExpected(19); + node.caseBlock = finishNode(caseBlock); + return finishNode(node); + } + function parseThrowStatement() { + var node = createNode(239); + parseExpected(105); + node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); + parseSemicolon(); + return finishNode(node); + } + function parseTryStatement() { + var node = createNode(240); + parseExpected(107); + node.tryBlock = parseBlock(false); + node.catchClause = token() === 79 ? parseCatchClause() : undefined; + if (!node.catchClause || token() === 92) { + parseExpected(92); + node.finallyBlock = parseBlock(false); + } + return finishNode(node); + } + function parseCatchClause() { + var result = createNode(280); + parseExpected(79); + if (parseOptional(20)) { + result.variableDeclaration = parseVariableDeclaration(); + parseExpected(21); + } + else { + result.variableDeclaration = undefined; + } + result.block = parseBlock(false); + return finishNode(result); + } + function parseDebuggerStatement() { + var node = createNode(241); + parseExpected(83); + parseSemicolon(); + return finishNode(node); + } + function parseExpressionOrLabeledStatement() { + var node = createNodeWithJSDoc(0); + var expression = allowInAnd(parseExpression); + if (expression.kind === 75 && parseOptional(58)) { + node.kind = 238; + node.label = expression; + node.statement = parseStatement(); + } + else { + node.kind = 226; + node.expression = expression; + parseSemicolon(); + } + return finishNode(node); + } + function nextTokenIsIdentifierOrKeywordOnSameLine() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsClassKeywordOnSameLine() { + nextToken(); + return token() === 80 && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsFunctionKeywordOnSameLine() { + nextToken(); + return token() === 94 && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() { + nextToken(); + return (ts.tokenIsIdentifierOrKeyword(token()) || token() === 8 || token() === 9 || token() === 10) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { + while (true) { + switch (token()) { + case 109: + case 115: + case 81: + case 94: + case 80: + case 88: + return true; + case 114: + case 145: + return nextTokenIsIdentifierOnSameLine(); + case 135: + case 136: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 122: + case 126: + case 130: + case 117: + case 118: + case 119: + case 138: + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; + case 150: + nextToken(); + return token() === 18 || token() === 75 || token() === 89; + case 96: + nextToken(); + return token() === 10 || token() === 41 || + token() === 18 || ts.tokenIsIdentifierOrKeyword(token()); + case 89: + var currentToken_1 = nextToken(); + if (currentToken_1 === 145) { + currentToken_1 = lookAhead(nextToken); + } + if (currentToken_1 === 62 || currentToken_1 === 41 || + currentToken_1 === 18 || currentToken_1 === 84 || + currentToken_1 === 123) { + return true; + } + continue; + case 120: + nextToken(); + continue; + default: + return false; + } + } + } + function isStartOfDeclaration() { + return lookAhead(isDeclaration); + } + function isStartOfStatement() { + switch (token()) { + case 59: + case 26: + case 18: + case 109: + case 115: + case 94: + case 80: + case 88: + case 95: + case 86: + case 111: + case 93: + case 82: + case 77: + case 101: + case 112: + case 103: + case 105: + case 107: + case 83: + case 79: + case 92: + return true; + case 96: + return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot); + case 81: + case 89: + return isStartOfDeclaration(); + case 126: + case 130: + case 114: + case 135: + case 136: + case 145: + case 150: + return true; + case 119: + case 117: + case 118: + case 120: + case 138: + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + default: + return isStartOfExpression(); + } + } + function nextTokenIsIdentifierOrStartOfDestructuring() { + nextToken(); + return isIdentifier() || token() === 18 || token() === 22; + } + function isLetDeclaration() { + return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring); + } + function parseStatement() { + switch (token()) { + case 26: + return parseEmptyStatement(); + case 18: + return parseBlock(false); + case 109: + return parseVariableStatement(createNodeWithJSDoc(242)); + case 115: + if (isLetDeclaration()) { + return parseVariableStatement(createNodeWithJSDoc(242)); + } + break; + case 94: + return parseFunctionDeclaration(createNodeWithJSDoc(244)); + case 80: + return parseClassDeclaration(createNodeWithJSDoc(245)); + case 95: + return parseIfStatement(); + case 86: + return parseDoStatement(); + case 111: + return parseWhileStatement(); + case 93: + return parseForOrForInOrForOfStatement(); + case 82: + return parseBreakOrContinueStatement(233); + case 77: + return parseBreakOrContinueStatement(234); + case 101: + return parseReturnStatement(); + case 112: + return parseWithStatement(); + case 103: + return parseSwitchStatement(); + case 105: + return parseThrowStatement(); + case 107: + case 79: + case 92: + return parseTryStatement(); + case 83: + return parseDebuggerStatement(); + case 59: + return parseDeclaration(); + case 126: + case 114: + case 145: + case 135: + case 136: + case 130: + case 81: + case 88: + case 89: + case 96: + case 117: + case 118: + case 119: + case 122: + case 120: + case 138: + case 150: + if (isStartOfDeclaration()) { + return parseDeclaration(); + } + break; + } + return parseExpressionOrLabeledStatement(); + } + function isDeclareModifier(modifier) { + return modifier.kind === 130; + } + function parseDeclaration() { + var modifiers = lookAhead(function () { return (parseDecorators(), parseModifiers()); }); + var isAmbient = ts.some(modifiers, isDeclareModifier); + if (isAmbient) { + var node_3 = tryReuseAmbientDeclaration(); + if (node_3) { + return node_3; + } + } + var node = createNodeWithJSDoc(0); + node.decorators = parseDecorators(); + node.modifiers = parseModifiers(); + if (isAmbient) { + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var m = _a[_i]; + m.flags |= 8388608; + } + return doInsideOfContext(8388608, function () { return parseDeclarationWorker(node); }); + } + else { + return parseDeclarationWorker(node); + } + } + function tryReuseAmbientDeclaration() { + return doInsideOfContext(8388608, function () { + var node = currentNode(parsingContext); + if (node) { + return consumeNode(node); + } + }); + } + function parseDeclarationWorker(node) { + switch (token()) { + case 109: + case 115: + case 81: + return parseVariableStatement(node); + case 94: + return parseFunctionDeclaration(node); + case 80: + return parseClassDeclaration(node); + case 114: + return parseInterfaceDeclaration(node); + case 145: + return parseTypeAliasDeclaration(node); + case 88: + return parseEnumDeclaration(node); + case 150: + case 135: + case 136: + return parseModuleDeclaration(node); + case 96: + return parseImportDeclarationOrImportEqualsDeclaration(node); + case 89: + nextToken(); + switch (token()) { + case 84: + case 62: + return parseExportAssignment(node); + case 123: + return parseNamespaceExportDeclaration(node); + default: + return parseExportDeclaration(node); + } + default: + if (node.decorators || node.modifiers) { + var missing = createMissingNode(264, true, ts.Diagnostics.Declaration_expected); + missing.pos = node.pos; + missing.decorators = node.decorators; + missing.modifiers = node.modifiers; + return finishNode(missing); + } + return undefined; + } + } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10); + } + function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) { + if (token() !== 18 && canParseSemicolon()) { + parseSemicolon(); + return; + } + return parseFunctionBlock(flags, diagnosticMessage); + } + function parseArrayBindingElement() { + if (token() === 27) { + return createNode(215); + } + var node = createNode(191); + node.dotDotDotToken = parseOptionalToken(25); + node.name = parseIdentifierOrPattern(); + node.initializer = parseInitializer(); + return finishNode(node); + } + function parseObjectBindingElement() { + var node = createNode(191); + node.dotDotDotToken = parseOptionalToken(25); + var tokenIsIdentifier = isIdentifier(); + var propertyName = parsePropertyName(); + if (tokenIsIdentifier && token() !== 58) { + node.name = propertyName; + } + else { + parseExpected(58); + node.propertyName = propertyName; + node.name = parseIdentifierOrPattern(); + } + node.initializer = parseInitializer(); + return finishNode(node); + } + function parseObjectBindingPattern() { + var node = createNode(189); + parseExpected(18); + node.elements = parseDelimitedList(9, parseObjectBindingElement); + parseExpected(19); + return finishNode(node); + } + function parseArrayBindingPattern() { + var node = createNode(190); + parseExpected(22); + node.elements = parseDelimitedList(10, parseArrayBindingElement); + parseExpected(23); + return finishNode(node); + } + function isIdentifierOrPrivateIdentifierOrPattern() { + return token() === 18 + || token() === 22 + || token() === 76 + || isIdentifier(); + } + function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) { + if (token() === 22) { + return parseArrayBindingPattern(); + } + if (token() === 18) { + return parseObjectBindingPattern(); + } + return parseIdentifier(undefined, privateIdentifierDiagnosticMessage); + } + function parseVariableDeclarationAllowExclamation() { + return parseVariableDeclaration(true); + } + function parseVariableDeclaration(allowExclamation) { + var node = createNode(242); + node.name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations); + if (allowExclamation && node.name.kind === 75 && + token() === 53 && !scanner.hasPrecedingLineBreak()) { + node.exclamationToken = parseTokenNode(); + } + node.type = parseTypeAnnotation(); + if (!isInOrOfKeyword(token())) { + node.initializer = parseInitializer(); + } + return finishNode(node); + } + function parseVariableDeclarationList(inForStatementInitializer) { + var node = createNode(243); + switch (token()) { + case 109: + break; + case 115: + node.flags |= 1; + break; + case 81: + node.flags |= 2; + break; + default: + ts.Debug.fail(); + } + nextToken(); + if (token() === 152 && lookAhead(canFollowContextualOfKeyword)) { + node.declarations = createMissingList(); + } + else { + var savedDisallowIn = inDisallowInContext(); + setDisallowInContext(inForStatementInitializer); + node.declarations = parseDelimitedList(8, inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation); + setDisallowInContext(savedDisallowIn); + } + return finishNode(node); + } + function canFollowContextualOfKeyword() { + return nextTokenIsIdentifier() && nextToken() === 21; + } + function parseVariableStatement(node) { + node.kind = 225; + node.declarationList = parseVariableDeclarationList(false); + parseSemicolon(); + return finishNode(node); + } + function parseFunctionDeclaration(node) { + node.kind = 244; + parseExpected(94); + node.asteriskToken = parseOptionalToken(41); + node.name = hasModifierOfKind(node, 84) ? parseOptionalIdentifier() : parseIdentifier(); + var isGenerator = node.asteriskToken ? 1 : 0; + var isAsync = hasModifierOfKind(node, 126) ? 2 : 0; + fillSignature(58, isGenerator | isAsync, node); + node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, ts.Diagnostics.or_expected); + return finishNode(node); + } + function parseConstructorName() { + if (token() === 129) { + return parseExpected(129); + } + if (token() === 10 && lookAhead(nextToken) === 20) { + return tryParse(function () { + var literalNode = parseLiteralNode(); + return literalNode.text === "constructor" ? literalNode : undefined; + }); + } + } + function tryParseConstructorDeclaration(node) { + return tryParse(function () { + if (parseConstructorName()) { + node.kind = 162; + fillSignature(58, 0, node); + node.body = parseFunctionBlockOrSemicolon(0, ts.Diagnostics.or_expected); + return finishNode(node); + } + }); + } + function parseMethodDeclaration(node, asteriskToken, diagnosticMessage) { + node.kind = 161; + node.asteriskToken = asteriskToken; + var isGenerator = asteriskToken ? 1 : 0; + var isAsync = hasModifierOfKind(node, 126) ? 2 : 0; + fillSignature(58, isGenerator | isAsync, node); + node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage); + return finishNode(node); + } + function parsePropertyDeclaration(node) { + node.kind = 159; + if (!node.questionToken && token() === 53 && !scanner.hasPrecedingLineBreak()) { + node.exclamationToken = parseTokenNode(); + } + node.type = parseTypeAnnotation(); + node.initializer = doOutsideOfContext(8192 | 32768 | 4096, parseInitializer); + parseSemicolon(); + return finishNode(node); + } + function parsePropertyOrMethodDeclaration(node) { + var asteriskToken = parseOptionalToken(41); + node.name = parsePropertyName(); + node.questionToken = parseOptionalToken(57); + if (asteriskToken || token() === 20 || token() === 29) { + return parseMethodDeclaration(node, asteriskToken, ts.Diagnostics.or_expected); + } + return parsePropertyDeclaration(node); + } + function parseAccessorDeclaration(node, kind) { + node.kind = kind; + node.name = parsePropertyName(); + fillSignature(58, 0, node); + node.body = parseFunctionBlockOrSemicolon(0); + return finishNode(node); + } + function isClassMemberStart() { + var idToken; + if (token() === 59) { + return true; + } + while (ts.isModifierKind(token())) { + idToken = token(); + if (ts.isClassMemberModifier(idToken)) { + return true; + } + nextToken(); + } + if (token() === 41) { + return true; + } + if (isLiteralPropertyName()) { + idToken = token(); + nextToken(); + } + if (token() === 22) { + return true; + } + if (idToken !== undefined) { + if (!ts.isKeyword(idToken) || idToken === 142 || idToken === 131) { + return true; + } + switch (token()) { + case 20: + case 29: + case 53: + case 58: + case 62: + case 57: + return true; + default: + return canParseSemicolon(); + } + } + return false; + } + function parseDecorators() { + var list; + var listPos = getNodePos(); + while (true) { + var decoratorStart = getNodePos(); + if (!parseOptional(59)) { + break; + } + var decorator = createNode(157, decoratorStart); + decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); + finishNode(decorator); + (list || (list = [])).push(decorator); + } + return list && createNodeArray(list, listPos); + } + function parseModifiers(permitInvalidConstAsModifier) { + var list; + var listPos = getNodePos(); + while (true) { + var modifierStart = scanner.getStartPos(); + var modifierKind = token(); + if (token() === 81 && permitInvalidConstAsModifier) { + if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) { + break; + } + } + else { + if (!parseAnyContextualModifier()) { + break; + } + } + var modifier = finishNode(createNode(modifierKind, modifierStart)); + (list || (list = [])).push(modifier); + } + return list && createNodeArray(list, listPos); + } + function parseModifiersForArrowFunction() { + var modifiers; + if (token() === 126) { + var modifierStart = scanner.getStartPos(); + var modifierKind = token(); + nextToken(); + var modifier = finishNode(createNode(modifierKind, modifierStart)); + modifiers = createNodeArray([modifier], modifierStart); + } + return modifiers; + } + function parseClassElement() { + if (token() === 26) { + var result = createNode(222); + nextToken(); + return finishNode(result); + } + var node = createNodeWithJSDoc(0); + node.decorators = parseDecorators(); + node.modifiers = parseModifiers(true); + if (parseContextualModifier(131)) { + return parseAccessorDeclaration(node, 163); + } + if (parseContextualModifier(142)) { + return parseAccessorDeclaration(node, 164); + } + if (token() === 129 || token() === 10) { + var constructorDeclaration = tryParseConstructorDeclaration(node); + if (constructorDeclaration) { + return constructorDeclaration; + } + } + if (isIndexSignature()) { + return parseIndexSignatureDeclaration(node); + } + if (ts.tokenIsIdentifierOrKeyword(token()) || + token() === 10 || + token() === 8 || + token() === 41 || + token() === 22) { + var isAmbient = node.modifiers && ts.some(node.modifiers, isDeclareModifier); + if (isAmbient) { + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var m = _a[_i]; + m.flags |= 8388608; + } + return doInsideOfContext(8388608, function () { return parsePropertyOrMethodDeclaration(node); }); + } + else { + return parsePropertyOrMethodDeclaration(node); + } + } + if (node.decorators || node.modifiers) { + node.name = createMissingNode(75, true, ts.Diagnostics.Declaration_expected); + return parsePropertyDeclaration(node); + } + return ts.Debug.fail("Should not have attempted to parse class member declaration."); + } + function parseClassExpression() { + return parseClassDeclarationOrExpression(createNodeWithJSDoc(0), 214); + } + function parseClassDeclaration(node) { + return parseClassDeclarationOrExpression(node, 245); + } + function parseClassDeclarationOrExpression(node, kind) { + node.kind = kind; + parseExpected(80); + node.name = parseNameOfClassDeclarationOrExpression(); + node.typeParameters = parseTypeParameters(); + node.heritageClauses = parseHeritageClauses(); + if (parseExpected(18)) { + node.members = parseClassMembers(); + parseExpected(19); + } + else { + node.members = createMissingList(); + } + return finishNode(node); + } + function parseNameOfClassDeclarationOrExpression() { + return isIdentifier() && !isImplementsClause() + ? parseIdentifier() + : undefined; + } + function isImplementsClause() { + return token() === 113 && lookAhead(nextTokenIsIdentifierOrKeyword); + } + function parseHeritageClauses() { + if (isHeritageClause()) { + return parseList(22, parseHeritageClause); + } + return undefined; + } + function parseHeritageClause() { + var tok = token(); + ts.Debug.assert(tok === 90 || tok === 113); + var node = createNode(279); + node.token = tok; + nextToken(); + node.types = parseDelimitedList(7, parseExpressionWithTypeArguments); + return finishNode(node); + } + function parseExpressionWithTypeArguments() { + var node = createNode(216); + node.expression = parseLeftHandSideExpressionOrHigher(); + node.typeArguments = tryParseTypeArguments(); + return finishNode(node); + } + function tryParseTypeArguments() { + return token() === 29 ? + parseBracketedList(20, parseType, 29, 31) : undefined; + } + function isHeritageClause() { + return token() === 90 || token() === 113; + } + function parseClassMembers() { + return parseList(5, parseClassElement); + } + function parseInterfaceDeclaration(node) { + node.kind = 246; + parseExpected(114); + node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); + node.heritageClauses = parseHeritageClauses(); + node.members = parseObjectTypeMembers(); + return finishNode(node); + } + function parseTypeAliasDeclaration(node) { + node.kind = 247; + parseExpected(145); + node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); + parseExpected(62); + node.type = parseType(); + parseSemicolon(); + return finishNode(node); + } + function parseEnumMember() { + var node = createNodeWithJSDoc(284); + node.name = parsePropertyName(); + node.initializer = allowInAnd(parseInitializer); + return finishNode(node); + } + function parseEnumDeclaration(node) { + node.kind = 248; + parseExpected(88); + node.name = parseIdentifier(); + if (parseExpected(18)) { + node.members = doOutsideOfYieldAndAwaitContext(function () { return parseDelimitedList(6, parseEnumMember); }); + parseExpected(19); + } + else { + node.members = createMissingList(); + } + return finishNode(node); + } + function parseModuleBlock() { + var node = createNode(250); + if (parseExpected(18)) { + node.statements = parseList(1, parseStatement); + parseExpected(19); + } + else { + node.statements = createMissingList(); + } + return finishNode(node); + } + function parseModuleOrNamespaceDeclaration(node, flags) { + node.kind = 249; + var namespaceFlag = flags & 16; + node.flags |= flags; + node.name = parseIdentifier(); + node.body = parseOptional(24) + ? parseModuleOrNamespaceDeclaration(createNode(0), 4 | namespaceFlag) + : parseModuleBlock(); + return finishNode(node); + } + function parseAmbientExternalModuleDeclaration(node) { + node.kind = 249; + if (token() === 150) { + node.name = parseIdentifier(); + node.flags |= 1024; + } + else { + node.name = parseLiteralNode(); + node.name.text = internIdentifier(node.name.text); + } + if (token() === 18) { + node.body = parseModuleBlock(); + } + else { + parseSemicolon(); + } + return finishNode(node); + } + function parseModuleDeclaration(node) { + var flags = 0; + if (token() === 150) { + return parseAmbientExternalModuleDeclaration(node); + } + else if (parseOptional(136)) { + flags |= 16; + } + else { + parseExpected(135); + if (token() === 10) { + return parseAmbientExternalModuleDeclaration(node); + } + } + return parseModuleOrNamespaceDeclaration(node, flags); + } + function isExternalModuleReference() { + return token() === 139 && + lookAhead(nextTokenIsOpenParen); + } + function nextTokenIsOpenParen() { + return nextToken() === 20; + } + function nextTokenIsSlash() { + return nextToken() === 43; + } + function parseNamespaceExportDeclaration(node) { + node.kind = 252; + parseExpected(123); + parseExpected(136); + node.name = parseIdentifier(); + parseSemicolon(); + return finishNode(node); + } + function parseImportDeclarationOrImportEqualsDeclaration(node) { + parseExpected(96); + var afterImportPos = scanner.getStartPos(); + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + } + var isTypeOnly = false; + if (token() !== 149 && + (identifier === null || identifier === void 0 ? void 0 : identifier.escapedText) === "type" && + (isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration())) { + isTypeOnly = true; + identifier = isIdentifier() ? parseIdentifier() : undefined; + } + if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) { + return parseImportEqualsDeclaration(node, identifier, isTypeOnly); + } + node.kind = 254; + if (identifier || + token() === 41 || + token() === 18) { + node.importClause = parseImportClause(identifier, afterImportPos, isTypeOnly); + parseExpected(149); + } + node.moduleSpecifier = parseModuleSpecifier(); + parseSemicolon(); + return finishNode(node); + } + function tokenAfterImportDefinitelyProducesImportDeclaration() { + return token() === 41 || token() === 18; + } + function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() { + return token() === 27 || token() === 149; + } + function parseImportEqualsDeclaration(node, identifier, isTypeOnly) { + node.kind = 253; + node.name = identifier; + parseExpected(62); + node.moduleReference = parseModuleReference(); + parseSemicolon(); + var finished = finishNode(node); + if (isTypeOnly) { + parseErrorAtRange(finished, ts.Diagnostics.Only_ECMAScript_imports_may_use_import_type); + } + return finished; + } + function parseImportClause(identifier, fullStart, isTypeOnly) { + var importClause = createNode(255, fullStart); + importClause.isTypeOnly = isTypeOnly; + if (identifier) { + importClause.name = identifier; + } + if (!importClause.name || + parseOptional(27)) { + importClause.namedBindings = token() === 41 ? parseNamespaceImport() : parseNamedImportsOrExports(257); + } + return finishNode(importClause); + } + function parseModuleReference() { + return isExternalModuleReference() + ? parseExternalModuleReference() + : parseEntityName(false); + } + function parseExternalModuleReference() { + var node = createNode(265); + parseExpected(139); + parseExpected(20); + node.expression = parseModuleSpecifier(); + parseExpected(21); + return finishNode(node); + } + function parseModuleSpecifier() { + if (token() === 10) { + var result = parseLiteralNode(); + result.text = internIdentifier(result.text); + return result; + } + else { + return parseExpression(); + } + } + function parseNamespaceImport() { + var namespaceImport = createNode(256); + parseExpected(41); + parseExpected(123); + namespaceImport.name = parseIdentifier(); + return finishNode(namespaceImport); + } + function parseNamedImportsOrExports(kind) { + var node = createNode(kind); + node.elements = parseBracketedList(23, kind === 257 ? parseImportSpecifier : parseExportSpecifier, 18, 19); + return finishNode(node); + } + function parseExportSpecifier() { + return parseImportOrExportSpecifier(263); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(258); + } + function parseImportOrExportSpecifier(kind) { + var node = createNode(kind); + var checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier(); + var checkIdentifierStart = scanner.getTokenPos(); + var checkIdentifierEnd = scanner.getTextPos(); + var identifierName = parseIdentifierName(); + if (token() === 123) { + node.propertyName = identifierName; + parseExpected(123); + checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier(); + checkIdentifierStart = scanner.getTokenPos(); + checkIdentifierEnd = scanner.getTextPos(); + node.name = parseIdentifierName(); + } + else { + node.name = identifierName; + } + if (kind === 258 && checkIdentifierIsKeyword) { + parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected); + } + return finishNode(node); + } + function parseNamespaceExport(pos) { + var node = createNode(262, pos); + node.name = parseIdentifier(); + return finishNode(node); + } + function parseExportDeclaration(node) { + node.kind = 260; + node.isTypeOnly = parseOptional(145); + var namespaceExportPos = scanner.getStartPos(); + if (parseOptional(41)) { + if (parseOptional(123)) { + node.exportClause = parseNamespaceExport(namespaceExportPos); + } + parseExpected(149); + node.moduleSpecifier = parseModuleSpecifier(); + } + else { + node.exportClause = parseNamedImportsOrExports(261); + if (token() === 149 || (token() === 10 && !scanner.hasPrecedingLineBreak())) { + parseExpected(149); + node.moduleSpecifier = parseModuleSpecifier(); + } + } + parseSemicolon(); + return finishNode(node); + } + function parseExportAssignment(node) { + node.kind = 259; + if (parseOptional(62)) { + node.isExportEquals = true; + } + else { + parseExpected(84); + } + node.expression = parseAssignmentExpressionOrHigher(); + parseSemicolon(); + return finishNode(node); + } + function setExternalModuleIndicator(sourceFile) { + sourceFile.externalModuleIndicator = + ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) || + getImportMetaIfNecessary(sourceFile); + } + function isAnExternalModuleIndicatorNode(node) { + return hasModifierOfKind(node, 89) + || node.kind === 253 && node.moduleReference.kind === 265 + || node.kind === 254 + || node.kind === 259 + || node.kind === 260 ? node : undefined; + } + function getImportMetaIfNecessary(sourceFile) { + return sourceFile.flags & 2097152 ? + walkTreeForExternalModuleIndicators(sourceFile) : + undefined; + } + function walkTreeForExternalModuleIndicators(node) { + return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators); + } + function hasModifierOfKind(node, kind) { + return ts.some(node.modifiers, function (m) { return m.kind === kind; }); + } + function isImportMeta(node) { + return ts.isMetaProperty(node) && node.keywordToken === 96 && node.name.escapedText === "meta"; + } + var JSDocParser; + (function (JSDocParser) { + function parseJSDocTypeExpressionForTests(content, start, length) { + initializeState(content, 99, undefined, 1); + sourceFile = createSourceFile("file.js", 99, 1, false); + scanner.setText(content, start, length); + currentToken = scanner.scan(); + var jsDocTypeExpression = parseJSDocTypeExpression(); + var diagnostics = parseDiagnostics; + clearState(); + return jsDocTypeExpression ? { jsDocTypeExpression: jsDocTypeExpression, diagnostics: diagnostics } : undefined; + } + JSDocParser.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests; + function parseJSDocTypeExpression(mayOmitBraces) { + var result = createNode(294); + var hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18); + result.type = doInsideOfContext(4194304, parseJSDocType); + if (!mayOmitBraces || hasBrace) { + parseExpectedJSDoc(19); + } + fixupParentReferences(result); + return finishNode(result); + } + JSDocParser.parseJSDocTypeExpression = parseJSDocTypeExpression; + function parseIsolatedJSDocComment(content, start, length) { + initializeState(content, 99, undefined, 1); + sourceFile = { languageVariant: 0, text: content }; + var jsDoc = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); }); + var diagnostics = parseDiagnostics; + clearState(); + return jsDoc ? { jsDoc: jsDoc, diagnostics: diagnostics } : undefined; + } + JSDocParser.parseIsolatedJSDocComment = parseIsolatedJSDocComment; + function parseJSDocComment(parent, start, length) { + var _a; + var saveToken = currentToken; + var saveParseDiagnosticsLength = parseDiagnostics.length; + var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + var comment = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); }); + if (comment) { + comment.parent = parent; + } + if (contextFlags & 131072) { + if (!sourceFile.jsDocDiagnostics) { + sourceFile.jsDocDiagnostics = []; + } + (_a = sourceFile.jsDocDiagnostics).push.apply(_a, parseDiagnostics); + } + currentToken = saveToken; + parseDiagnostics.length = saveParseDiagnosticsLength; + parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; + return comment; + } + JSDocParser.parseJSDocComment = parseJSDocComment; + function parseJSDocCommentWorker(start, length) { + if (start === void 0) { start = 0; } + var content = sourceText; + var end = length === undefined ? content.length : start + length; + length = end - start; + ts.Debug.assert(start >= 0); + ts.Debug.assert(start <= end); + ts.Debug.assert(end <= content.length); + if (!isJSDocLikeText(content, start)) { + return undefined; + } + var tags; + var tagsPos; + var tagsEnd; + var comments = []; + return scanner.scanRange(start + 3, length - 5, function () { + var state = 1; + var margin; + var indent = start - Math.max(content.lastIndexOf("\n", start), 0) + 4; + function pushComment(text) { + if (!margin) { + margin = indent; + } + comments.push(text); + indent += text.length; + } + nextTokenJSDoc(); + while (parseOptionalJsdoc(5)) + ; + if (parseOptionalJsdoc(4)) { + state = 0; + indent = 0; + } + loop: while (true) { + switch (token()) { + case 59: + if (state === 0 || state === 1) { + removeTrailingWhitespace(comments); + addTag(parseTag(indent)); + state = 0; + margin = undefined; + } + else { + pushComment(scanner.getTokenText()); + } + break; + case 4: + comments.push(scanner.getTokenText()); + state = 0; + indent = 0; + break; + case 41: + var asterisk = scanner.getTokenText(); + if (state === 1 || state === 2) { + state = 2; + pushComment(asterisk); + } + else { + state = 1; + indent += asterisk.length; + } + break; + case 5: + var whitespace = scanner.getTokenText(); + if (state === 2) { + comments.push(whitespace); + } + else if (margin !== undefined && indent + whitespace.length > margin) { + comments.push(whitespace.slice(margin - indent - 1)); + } + indent += whitespace.length; + break; + case 1: + break loop; + default: + state = 2; + pushComment(scanner.getTokenText()); + break; + } + nextTokenJSDoc(); + } + removeLeadingNewlines(comments); + removeTrailingWhitespace(comments); + return createJSDocComment(); + }); + function removeLeadingNewlines(comments) { + while (comments.length && (comments[0] === "\n" || comments[0] === "\r")) { + comments.shift(); + } + } + function removeTrailingWhitespace(comments) { + while (comments.length && comments[comments.length - 1].trim() === "") { + comments.pop(); + } + } + function createJSDocComment() { + var result = createNode(303, start); + result.tags = tags && createNodeArray(tags, tagsPos, tagsEnd); + result.comment = comments.length ? comments.join("") : undefined; + return finishNode(result, end); + } + function isNextNonwhitespaceTokenEndOfFile() { + while (true) { + nextTokenJSDoc(); + if (token() === 1) { + return true; + } + if (!(token() === 5 || token() === 4)) { + return false; + } + } + } + function skipWhitespace() { + if (token() === 5 || token() === 4) { + if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) { + return; + } + } + while (token() === 5 || token() === 4) { + nextTokenJSDoc(); + } + } + function skipWhitespaceOrAsterisk() { + if (token() === 5 || token() === 4) { + if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) { + return ""; + } + } + var precedingLineBreak = scanner.hasPrecedingLineBreak(); + var seenLineBreak = false; + var indentText = ""; + while ((precedingLineBreak && token() === 41) || token() === 5 || token() === 4) { + indentText += scanner.getTokenText(); + if (token() === 4) { + precedingLineBreak = true; + seenLineBreak = true; + indentText = ""; + } + else if (token() === 41) { + precedingLineBreak = false; + } + nextTokenJSDoc(); + } + return seenLineBreak ? indentText : ""; + } + function parseTag(margin) { + ts.Debug.assert(token() === 59); + var start = scanner.getTokenPos(); + nextTokenJSDoc(); + var tagName = parseJSDocIdentifierName(undefined); + var indentText = skipWhitespaceOrAsterisk(); + var tag; + switch (tagName.escapedText) { + case "author": + tag = parseAuthorTag(start, tagName, margin); + break; + case "augments": + case "extends": + tag = parseAugmentsTag(start, tagName); + break; + case "class": + case "constructor": + tag = parseSimpleTag(start, 309, tagName); + break; + case "public": + tag = parseSimpleTag(start, 310, tagName); + break; + case "private": + tag = parseSimpleTag(start, 311, tagName); + break; + case "protected": + tag = parseSimpleTag(start, 312, tagName); + break; + case "readonly": + tag = parseSimpleTag(start, 313, tagName); + break; + case "this": + tag = parseThisTag(start, tagName); + break; + case "enum": + tag = parseEnumTag(start, tagName); + break; + case "arg": + case "argument": + case "param": + return parseParameterOrPropertyTag(start, tagName, 2, margin); + case "return": + case "returns": + tag = parseReturnTag(start, tagName); + break; + case "template": + tag = parseTemplateTag(start, tagName); + break; + case "type": + tag = parseTypeTag(start, tagName); + break; + case "typedef": + tag = parseTypedefTag(start, tagName, margin); + break; + case "callback": + tag = parseCallbackTag(start, tagName, margin); + break; + default: + tag = parseUnknownTag(start, tagName); + break; + } + if (!tag.comment) { + if (!indentText) { + margin += tag.end - tag.pos; + } + tag.comment = parseTagComments(margin, indentText.slice(margin)); + } + return tag; + } + function parseTagComments(indent, initialMargin) { + var comments = []; + var state = 0; + var margin; + function pushComment(text) { + if (!margin) { + margin = indent; + } + comments.push(text); + indent += text.length; + } + if (initialMargin) { + pushComment(initialMargin); + state = 2; + } + var tok = token(); + loop: while (true) { + switch (tok) { + case 4: + if (state >= 1) { + state = 0; + comments.push(scanner.getTokenText()); + } + indent = 0; + break; + case 59: + if (state === 3) { + comments.push(scanner.getTokenText()); + break; + } + scanner.setTextPos(scanner.getTextPos() - 1); + case 1: + break loop; + case 5: + if (state === 2 || state === 3) { + pushComment(scanner.getTokenText()); + } + else { + var whitespace = scanner.getTokenText(); + if (margin !== undefined && indent + whitespace.length > margin) { + comments.push(whitespace.slice(margin - indent)); + } + indent += whitespace.length; + } + break; + case 18: + state = 2; + if (lookAhead(function () { return nextTokenJSDoc() === 59 && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && scanner.getTokenText() === "link"; })) { + pushComment(scanner.getTokenText()); + nextTokenJSDoc(); + pushComment(scanner.getTokenText()); + nextTokenJSDoc(); + } + pushComment(scanner.getTokenText()); + break; + case 61: + if (state === 3) { + state = 2; + } + else { + state = 3; + } + pushComment(scanner.getTokenText()); + break; + case 41: + if (state === 0) { + state = 1; + indent += 1; + break; + } + default: + if (state !== 3) { + state = 2; + } + pushComment(scanner.getTokenText()); + break; + } + tok = nextTokenJSDoc(); + } + removeLeadingNewlines(comments); + removeTrailingWhitespace(comments); + return comments.length === 0 ? undefined : comments.join(""); + } + function parseUnknownTag(start, tagName) { + var result = createNode(306, start); + result.tagName = tagName; + return finishNode(result); + } + function addTag(tag) { + if (!tag) { + return; + } + if (!tags) { + tags = [tag]; + tagsPos = tag.pos; + } + else { + tags.push(tag); + } + tagsEnd = tag.end; + } + function tryParseTypeExpression() { + skipWhitespaceOrAsterisk(); + return token() === 18 ? parseJSDocTypeExpression() : undefined; + } + function parseBracketNameInPropertyAndParamTag() { + var isBracketed = parseOptionalJsdoc(22); + if (isBracketed) { + skipWhitespace(); + } + var isBackquoted = parseOptionalJsdoc(61); + var name = parseJSDocEntityName(); + if (isBackquoted) { + parseExpectedTokenJSDoc(61); + } + if (isBracketed) { + skipWhitespace(); + if (parseOptionalToken(62)) { + parseExpression(); + } + parseExpected(23); + } + return { name: name, isBracketed: isBracketed }; + } + function isObjectOrObjectArrayTypeReference(node) { + switch (node.kind) { + case 141: + return true; + case 174: + return isObjectOrObjectArrayTypeReference(node.elementType); + default: + return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments; + } + } + function parseParameterOrPropertyTag(start, tagName, target, indent) { + var typeExpression = tryParseTypeExpression(); + var isNameFirst = !typeExpression; + skipWhitespaceOrAsterisk(); + var _a = parseBracketNameInPropertyAndParamTag(), name = _a.name, isBracketed = _a.isBracketed; + skipWhitespace(); + if (isNameFirst) { + typeExpression = tryParseTypeExpression(); + } + var result = target === 1 ? + createNode(322, start) : + createNode(316, start); + var comment = parseTagComments(indent + scanner.getStartPos() - start); + var nestedTypeLiteral = target !== 4 && parseNestedTypeLiteral(typeExpression, name, target, indent); + if (nestedTypeLiteral) { + typeExpression = nestedTypeLiteral; + isNameFirst = true; + } + result.tagName = tagName; + result.typeExpression = typeExpression; + result.name = name; + result.isNameFirst = isNameFirst; + result.isBracketed = isBracketed; + result.comment = comment; + return finishNode(result); + } + function parseNestedTypeLiteral(typeExpression, name, target, indent) { + if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) { + var typeLiteralExpression = createNode(294, scanner.getTokenPos()); + var child = void 0; + var jsdocTypeLiteral = void 0; + var start_3 = scanner.getStartPos(); + var children = void 0; + while (child = tryParse(function () { return parseChildParameterOrPropertyTag(target, indent, name); })) { + if (child.kind === 316 || child.kind === 322) { + children = ts.append(children, child); + } + } + if (children) { + jsdocTypeLiteral = createNode(304, start_3); + jsdocTypeLiteral.jsDocPropertyTags = children; + if (typeExpression.type.kind === 174) { + jsdocTypeLiteral.isArrayType = true; + } + typeLiteralExpression.type = finishNode(jsdocTypeLiteral); + return finishNode(typeLiteralExpression); + } + } + } + function parseReturnTag(start, tagName) { + if (ts.some(tags, ts.isJSDocReturnTag)) { + parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText); + } + var result = createNode(317, start); + result.tagName = tagName; + result.typeExpression = tryParseTypeExpression(); + return finishNode(result); + } + function parseTypeTag(start, tagName) { + if (ts.some(tags, ts.isJSDocTypeTag)) { + parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText); + } + var result = createNode(319, start); + result.tagName = tagName; + result.typeExpression = parseJSDocTypeExpression(true); + return finishNode(result); + } + function parseAuthorTag(start, tagName, indent) { + var result = createNode(308, start); + result.tagName = tagName; + var authorInfoWithEmail = tryParse(function () { return tryParseAuthorNameAndEmail(); }); + if (!authorInfoWithEmail) { + return finishNode(result); + } + result.comment = authorInfoWithEmail; + if (lookAhead(function () { return nextToken() !== 4; })) { + var comment = parseTagComments(indent); + if (comment) { + result.comment += comment; + } + } + return finishNode(result); + } + function tryParseAuthorNameAndEmail() { + var comments = []; + var seenLessThan = false; + var seenGreaterThan = false; + var token = scanner.getToken(); + loop: while (true) { + switch (token) { + case 75: + case 5: + case 24: + case 59: + comments.push(scanner.getTokenText()); + break; + case 29: + if (seenLessThan || seenGreaterThan) { + return; + } + seenLessThan = true; + comments.push(scanner.getTokenText()); + break; + case 31: + if (!seenLessThan || seenGreaterThan) { + return; + } + seenGreaterThan = true; + comments.push(scanner.getTokenText()); + scanner.setTextPos(scanner.getTokenPos() + 1); + break loop; + case 4: + case 1: + break loop; + } + token = nextTokenJSDoc(); + } + if (seenLessThan && seenGreaterThan) { + return comments.length === 0 ? undefined : comments.join(""); + } + } + function parseAugmentsTag(start, tagName) { + var result = createNode(307, start); + result.tagName = tagName; + result.class = parseExpressionWithTypeArgumentsForAugments(); + return finishNode(result); + } + function parseExpressionWithTypeArgumentsForAugments() { + var usedBrace = parseOptional(18); + var node = createNode(216); + node.expression = parsePropertyAccessEntityNameExpression(); + node.typeArguments = tryParseTypeArguments(); + var res = finishNode(node); + if (usedBrace) { + parseExpected(19); + } + return res; + } + function parsePropertyAccessEntityNameExpression() { + var node = parseJSDocIdentifierName(); + while (parseOptional(24)) { + var prop = createNode(194, node.pos); + prop.expression = node; + prop.name = parseJSDocIdentifierName(); + node = finishNode(prop); + } + return node; + } + function parseSimpleTag(start, kind, tagName) { + var tag = createNode(kind, start); + tag.tagName = tagName; + return finishNode(tag); + } + function parseThisTag(start, tagName) { + var tag = createNode(318, start); + tag.tagName = tagName; + tag.typeExpression = parseJSDocTypeExpression(true); + skipWhitespace(); + return finishNode(tag); + } + function parseEnumTag(start, tagName) { + var tag = createNode(315, start); + tag.tagName = tagName; + tag.typeExpression = parseJSDocTypeExpression(true); + skipWhitespace(); + return finishNode(tag); + } + function parseTypedefTag(start, tagName, indent) { + var typeExpression = tryParseTypeExpression(); + skipWhitespaceOrAsterisk(); + var typedefTag = createNode(321, start); + typedefTag.tagName = tagName; + typedefTag.fullName = parseJSDocTypeNameWithNamespace(); + typedefTag.name = getJSDocTypeAliasName(typedefTag.fullName); + skipWhitespace(); + typedefTag.comment = parseTagComments(indent); + typedefTag.typeExpression = typeExpression; + var end; + if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) { + var child = void 0; + var jsdocTypeLiteral = void 0; + var childTypeTag = void 0; + while (child = tryParse(function () { return parseChildPropertyTag(indent); })) { + if (!jsdocTypeLiteral) { + jsdocTypeLiteral = createNode(304, start); + } + if (child.kind === 319) { + if (childTypeTag) { + break; + } + else { + childTypeTag = child; + } + } + else { + jsdocTypeLiteral.jsDocPropertyTags = ts.append(jsdocTypeLiteral.jsDocPropertyTags, child); + } + } + if (jsdocTypeLiteral) { + if (typeExpression && typeExpression.type.kind === 174) { + jsdocTypeLiteral.isArrayType = true; + } + typedefTag.typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ? + childTypeTag.typeExpression : + finishNode(jsdocTypeLiteral); + end = typedefTag.typeExpression.end; + } + } + return finishNode(typedefTag, end || typedefTag.comment !== undefined ? scanner.getStartPos() : (typedefTag.fullName || typedefTag.typeExpression || typedefTag.tagName).end); + } + function parseJSDocTypeNameWithNamespace(nested) { + var pos = scanner.getTokenPos(); + if (!ts.tokenIsIdentifierOrKeyword(token())) { + return undefined; + } + var typeNameOrNamespaceName = parseJSDocIdentifierName(); + if (parseOptional(24)) { + var jsDocNamespaceNode = createNode(249, pos); + if (nested) { + jsDocNamespaceNode.flags |= 4; + } + jsDocNamespaceNode.name = typeNameOrNamespaceName; + jsDocNamespaceNode.body = parseJSDocTypeNameWithNamespace(true); + return finishNode(jsDocNamespaceNode); + } + if (nested) { + typeNameOrNamespaceName.isInJSDocNamespace = true; + } + return typeNameOrNamespaceName; + } + function parseCallbackTag(start, tagName, indent) { + var callbackTag = createNode(314, start); + callbackTag.tagName = tagName; + callbackTag.fullName = parseJSDocTypeNameWithNamespace(); + callbackTag.name = getJSDocTypeAliasName(callbackTag.fullName); + skipWhitespace(); + callbackTag.comment = parseTagComments(indent); + var child; + var jsdocSignature = createNode(305, start); + jsdocSignature.parameters = []; + while (child = tryParse(function () { return parseChildParameterOrPropertyTag(4, indent); })) { + jsdocSignature.parameters = ts.append(jsdocSignature.parameters, child); + } + var returnTag = tryParse(function () { + if (parseOptionalJsdoc(59)) { + var tag = parseTag(indent); + if (tag && tag.kind === 317) { + return tag; + } + } + }); + if (returnTag) { + jsdocSignature.type = returnTag; + } + callbackTag.typeExpression = finishNode(jsdocSignature); + return finishNode(callbackTag); + } + function getJSDocTypeAliasName(fullName) { + if (fullName) { + var rightNode = fullName; + while (true) { + if (ts.isIdentifier(rightNode) || !rightNode.body) { + return ts.isIdentifier(rightNode) ? rightNode : rightNode.name; + } + rightNode = rightNode.body; + } + } + } + function escapedTextsEqual(a, b) { + while (!ts.isIdentifier(a) || !ts.isIdentifier(b)) { + if (!ts.isIdentifier(a) && !ts.isIdentifier(b) && a.right.escapedText === b.right.escapedText) { + a = a.left; + b = b.left; + } + else { + return false; + } + } + return a.escapedText === b.escapedText; + } + function parseChildPropertyTag(indent) { + return parseChildParameterOrPropertyTag(1, indent); + } + function parseChildParameterOrPropertyTag(target, indent, name) { + var canParseTag = true; + var seenAsterisk = false; + while (true) { + switch (nextTokenJSDoc()) { + case 59: + if (canParseTag) { + var child = tryParseChildTag(target, indent); + if (child && (child.kind === 316 || child.kind === 322) && + target !== 4 && + name && (ts.isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) { + return false; + } + return child; + } + seenAsterisk = false; + break; + case 4: + canParseTag = true; + seenAsterisk = false; + break; + case 41: + if (seenAsterisk) { + canParseTag = false; + } + seenAsterisk = true; + break; + case 75: + canParseTag = false; + break; + case 1: + return false; + } + } + } + function tryParseChildTag(target, indent) { + ts.Debug.assert(token() === 59); + var start = scanner.getStartPos(); + nextTokenJSDoc(); + var tagName = parseJSDocIdentifierName(); + skipWhitespace(); + var t; + switch (tagName.escapedText) { + case "type": + return target === 1 && parseTypeTag(start, tagName); + case "prop": + case "property": + t = 1; + break; + case "arg": + case "argument": + case "param": + t = 2 | 4; + break; + default: + return false; + } + if (!(target & t)) { + return false; + } + return parseParameterOrPropertyTag(start, tagName, target, indent); + } + function parseTemplateTag(start, tagName) { + var constraint; + if (token() === 18) { + constraint = parseJSDocTypeExpression(); + } + var typeParameters = []; + var typeParametersPos = getNodePos(); + do { + skipWhitespace(); + var typeParameter = createNode(155); + typeParameter.name = parseJSDocIdentifierName(ts.Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces); + finishNode(typeParameter); + skipWhitespace(); + typeParameters.push(typeParameter); + } while (parseOptionalJsdoc(27)); + var result = createNode(320, start); + result.tagName = tagName; + result.constraint = constraint; + result.typeParameters = createNodeArray(typeParameters, typeParametersPos); + finishNode(result); + return result; + } + function parseOptionalJsdoc(t) { + if (token() === t) { + nextTokenJSDoc(); + return true; + } + return false; + } + function parseJSDocEntityName() { + var entity = parseJSDocIdentifierName(); + if (parseOptional(22)) { + parseExpected(23); + } + while (parseOptional(24)) { + var name = parseJSDocIdentifierName(); + if (parseOptional(22)) { + parseExpected(23); + } + entity = createQualifiedName(entity, name); + } + return entity; + } + function parseJSDocIdentifierName(message) { + if (!ts.tokenIsIdentifierOrKeyword(token())) { + return createMissingNode(75, !message, message || ts.Diagnostics.Identifier_expected); + } + identifierCount++; + var pos = scanner.getTokenPos(); + var end = scanner.getTextPos(); + var result = createNode(75, pos); + if (token() !== 75) { + result.originalKeywordKind = token(); + } + result.escapedText = ts.escapeLeadingUnderscores(internIdentifier(scanner.getTokenValue())); + finishNode(result, end); + nextTokenJSDoc(); + return result; + } + } + })(JSDocParser = Parser.JSDocParser || (Parser.JSDocParser = {})); + })(Parser || (Parser = {})); + var IncrementalParser; + (function (IncrementalParser) { + function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { + aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2); + checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks); + if (ts.textChangeRangeIsUnchanged(textChangeRange)) { + return sourceFile; + } + if (sourceFile.statements.length === 0) { + return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, undefined, true, sourceFile.scriptKind); + } + var incrementalSourceFile = sourceFile; + ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed); + incrementalSourceFile.hasBeenIncrementallyParsed = true; + var oldText = sourceFile.text; + var syntaxCursor = createSyntaxCursor(sourceFile); + var changeRange = extendToAffectedRange(sourceFile, textChangeRange); + checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks); + ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start); + ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span)); + ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange))); + var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length; + updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks); + var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind); + return result; + } + IncrementalParser.updateSourceFile = updateSourceFile; + function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) { + if (isArray) { + visitArray(element); + } + else { + visitNode(element); + } + return; + function visitNode(node) { + var text = ""; + if (aggressiveChecks && shouldCheckNode(node)) { + text = oldText.substring(node.pos, node.end); + } + if (node._children) { + node._children = undefined; + } + node.pos += delta; + node.end += delta; + if (aggressiveChecks && shouldCheckNode(node)) { + ts.Debug.assert(text === newText.substring(node.pos, node.end)); + } + forEachChild(node, visitNode, visitArray); + if (ts.hasJSDocNodes(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode(jsDocComment); + } + } + checkNodePositions(node, aggressiveChecks); + } + function visitArray(array) { + array._children = undefined; + array.pos += delta; + array.end += delta; + for (var _i = 0, array_8 = array; _i < array_8.length; _i++) { + var node = array_8[_i]; + visitNode(node); + } + } + } + function shouldCheckNode(node) { + switch (node.kind) { + case 10: + case 8: + case 75: + return true; + } + return false; + } + function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) { + ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range"); + ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range"); + ts.Debug.assert(element.pos <= element.end); + element.pos = Math.min(element.pos, changeRangeNewEnd); + if (element.end >= changeRangeOldEnd) { + element.end += delta; + } + else { + element.end = Math.min(element.end, changeRangeNewEnd); + } + ts.Debug.assert(element.pos <= element.end); + if (element.parent) { + ts.Debug.assert(element.pos >= element.parent.pos); + ts.Debug.assert(element.end <= element.parent.end); + } + } + function checkNodePositions(node, aggressiveChecks) { + if (aggressiveChecks) { + var pos_2 = node.pos; + var visitNode_1 = function (child) { + ts.Debug.assert(child.pos >= pos_2); + pos_2 = child.end; + }; + if (ts.hasJSDocNodes(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode_1(jsDocComment); + } + } + forEachChild(node, visitNode_1); + ts.Debug.assert(pos_2 <= node.end); + } + } + function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) { + visitNode(sourceFile); + return; + function visitNode(child) { + ts.Debug.assert(child.pos <= child.end); + if (child.pos > changeRangeOldEnd) { + moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks); + return; + } + var fullEnd = child.end; + if (fullEnd >= changeStart) { + child.intersectsChange = true; + child._children = undefined; + adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + forEachChild(child, visitNode, visitArray); + if (ts.hasJSDocNodes(child)) { + for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode(jsDocComment); + } + } + checkNodePositions(child, aggressiveChecks); + return; + } + ts.Debug.assert(fullEnd < changeStart); + } + function visitArray(array) { + ts.Debug.assert(array.pos <= array.end); + if (array.pos > changeRangeOldEnd) { + moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks); + return; + } + var fullEnd = array.end; + if (fullEnd >= changeStart) { + array.intersectsChange = true; + array._children = undefined; + adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + for (var _i = 0, array_9 = array; _i < array_9.length; _i++) { + var node = array_9[_i]; + visitNode(node); + } + return; + } + ts.Debug.assert(fullEnd < changeStart); + } + } + function extendToAffectedRange(sourceFile, changeRange) { + var maxLookahead = 1; + var start = changeRange.span.start; + for (var i = 0; start > 0 && i <= maxLookahead; i++) { + var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); + ts.Debug.assert(nearestNode.pos <= start); + var position = nearestNode.pos; + start = Math.max(0, position - 1); + } + var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span)); + var finalLength = changeRange.newLength + (changeRange.span.start - start); + return ts.createTextChangeRange(finalSpan, finalLength); + } + function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) { + var bestResult = sourceFile; + var lastNodeEntirelyBeforePosition; + forEachChild(sourceFile, visit); + if (lastNodeEntirelyBeforePosition) { + var lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition); + if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) { + bestResult = lastChildOfLastEntireNodeBeforePosition; + } + } + return bestResult; + function getLastDescendant(node) { + while (true) { + var lastChild = ts.getLastChild(node); + if (lastChild) { + node = lastChild; + } + else { + return node; + } + } + } + function visit(child) { + if (ts.nodeIsMissing(child)) { + return; + } + if (child.pos <= position) { + if (child.pos >= bestResult.pos) { + bestResult = child; + } + if (position < child.end) { + forEachChild(child, visit); + return true; + } + else { + ts.Debug.assert(child.end <= position); + lastNodeEntirelyBeforePosition = child; + } + } + else { + ts.Debug.assert(child.pos > position); + return true; + } + } + } + function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) { + var oldText = sourceFile.text; + if (textChangeRange) { + ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length); + if (aggressiveChecks || ts.Debug.shouldAssert(3)) { + var oldTextPrefix = oldText.substr(0, textChangeRange.span.start); + var newTextPrefix = newText.substr(0, textChangeRange.span.start); + ts.Debug.assert(oldTextPrefix === newTextPrefix); + var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length); + var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length); + ts.Debug.assert(oldTextSuffix === newTextSuffix); + } + } + } + function createSyntaxCursor(sourceFile) { + var currentArray = sourceFile.statements; + var currentArrayIndex = 0; + ts.Debug.assert(currentArrayIndex < currentArray.length); + var current = currentArray[currentArrayIndex]; + var lastQueriedPosition = -1; + return { + currentNode: function (position) { + if (position !== lastQueriedPosition) { + if (current && current.end === position && currentArrayIndex < (currentArray.length - 1)) { + currentArrayIndex++; + current = currentArray[currentArrayIndex]; + } + if (!current || current.pos !== position) { + findHighestListElementThatStartsAtPosition(position); + } + } + lastQueriedPosition = position; + ts.Debug.assert(!current || current.pos === position); + return current; + } + }; + function findHighestListElementThatStartsAtPosition(position) { + currentArray = undefined; + currentArrayIndex = -1; + current = undefined; + forEachChild(sourceFile, visitNode, visitArray); + return; + function visitNode(node) { + if (position >= node.pos && position < node.end) { + forEachChild(node, visitNode, visitArray); + return true; + } + return false; + } + function visitArray(array) { + if (position >= array.pos && position < array.end) { + for (var i = 0; i < array.length; i++) { + var child = array[i]; + if (child) { + if (child.pos === position) { + currentArray = array; + currentArrayIndex = i; + current = child; + return true; + } + else { + if (child.pos < position && position < child.end) { + forEachChild(child, visitNode, visitArray); + return true; + } + } + } + } + } + return false; + } + } + } + })(IncrementalParser || (IncrementalParser = {})); + function isDeclarationFileName(fileName) { + return ts.fileExtensionIs(fileName, ".d.ts"); + } + ts.isDeclarationFileName = isDeclarationFileName; + function processCommentPragmas(context, sourceText) { + var pragmas = []; + for (var _i = 0, _a = ts.getLeadingCommentRanges(sourceText, 0) || ts.emptyArray; _i < _a.length; _i++) { + var range = _a[_i]; + var comment = sourceText.substring(range.pos, range.end); + extractPragmas(pragmas, range, comment); + } + context.pragmas = ts.createMap(); + for (var _b = 0, pragmas_1 = pragmas; _b < pragmas_1.length; _b++) { + var pragma = pragmas_1[_b]; + if (context.pragmas.has(pragma.name)) { + var currentValue = context.pragmas.get(pragma.name); + if (currentValue instanceof Array) { + currentValue.push(pragma.args); + } + else { + context.pragmas.set(pragma.name, [currentValue, pragma.args]); + } + continue; + } + context.pragmas.set(pragma.name, pragma.args); + } + } + ts.processCommentPragmas = processCommentPragmas; + function processPragmasIntoFields(context, reportDiagnostic) { + context.checkJsDirective = undefined; + context.referencedFiles = []; + context.typeReferenceDirectives = []; + context.libReferenceDirectives = []; + context.amdDependencies = []; + context.hasNoDefaultLib = false; + context.pragmas.forEach(function (entryOrList, key) { + switch (key) { + case "reference": { + var referencedFiles_1 = context.referencedFiles; + var typeReferenceDirectives_1 = context.typeReferenceDirectives; + var libReferenceDirectives_1 = context.libReferenceDirectives; + ts.forEach(ts.toArray(entryOrList), function (arg) { + var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path; + if (arg.arguments["no-default-lib"]) { + context.hasNoDefaultLib = true; + } + else if (types) { + typeReferenceDirectives_1.push({ pos: types.pos, end: types.end, fileName: types.value }); + } + else if (lib) { + libReferenceDirectives_1.push({ pos: lib.pos, end: lib.end, fileName: lib.value }); + } + else if (path) { + referencedFiles_1.push({ pos: path.pos, end: path.end, fileName: path.value }); + } + else { + reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, ts.Diagnostics.Invalid_reference_directive_syntax); + } + }); + break; + } + case "amd-dependency": { + context.amdDependencies = ts.map(ts.toArray(entryOrList), function (x) { return ({ name: x.arguments.name, path: x.arguments.path }); }); + break; + } + case "amd-module": { + if (entryOrList instanceof Array) { + for (var _i = 0, entryOrList_1 = entryOrList; _i < entryOrList_1.length; _i++) { + var entry = entryOrList_1[_i]; + if (context.moduleName) { + reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments); + } + context.moduleName = entry.arguments.name; + } + } + else { + context.moduleName = entryOrList.arguments.name; + } + break; + } + case "ts-nocheck": + case "ts-check": { + ts.forEach(ts.toArray(entryOrList), function (entry) { + if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) { + context.checkJsDirective = { + enabled: key === "ts-check", + end: entry.range.end, + pos: entry.range.pos + }; + } + }); + break; + } + case "jsx": return; + default: ts.Debug.fail("Unhandled pragma kind"); + } + }); + } + ts.processPragmasIntoFields = processPragmasIntoFields; + var namedArgRegExCache = ts.createMap(); + function getNamedArgRegEx(name) { + if (namedArgRegExCache.has(name)) { + return namedArgRegExCache.get(name); + } + var result = new RegExp("(\\s" + name + "\\s*=\\s*)('|\")(.+?)\\2", "im"); + namedArgRegExCache.set(name, result); + return result; + } + var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im; + var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im; + function extractPragmas(pragmas, range, text) { + var tripleSlash = range.kind === 2 && tripleSlashXMLCommentStartRegEx.exec(text); + if (tripleSlash) { + var name = tripleSlash[1].toLowerCase(); + var pragma = ts.commentPragmas[name]; + if (!pragma || !(pragma.kind & 1)) { + return; + } + if (pragma.args) { + var argument = {}; + for (var _i = 0, _a = pragma.args; _i < _a.length; _i++) { + var arg = _a[_i]; + var matcher = getNamedArgRegEx(arg.name); + var matchResult = matcher.exec(text); + if (!matchResult && !arg.optional) { + return; + } + else if (matchResult) { + if (arg.captureSpan) { + var startPos = range.pos + matchResult.index + matchResult[1].length + matchResult[2].length; + argument[arg.name] = { + value: matchResult[3], + pos: startPos, + end: startPos + matchResult[3].length + }; + } + else { + argument[arg.name] = matchResult[3]; + } + } + } + pragmas.push({ name: name, args: { arguments: argument, range: range } }); + } + else { + pragmas.push({ name: name, args: { arguments: {}, range: range } }); + } + return; + } + var singleLine = range.kind === 2 && singleLinePragmaRegEx.exec(text); + if (singleLine) { + return addPragmaForMatch(pragmas, range, 2, singleLine); + } + if (range.kind === 3) { + var multiLinePragmaRegEx = /\s*@(\S+)\s*(.*)\s*$/gim; + var multiLineMatch = void 0; + while (multiLineMatch = multiLinePragmaRegEx.exec(text)) { + addPragmaForMatch(pragmas, range, 4, multiLineMatch); + } + } + } + function addPragmaForMatch(pragmas, range, kind, match) { + if (!match) + return; + var name = match[1].toLowerCase(); + var pragma = ts.commentPragmas[name]; + if (!pragma || !(pragma.kind & kind)) { + return; + } + var args = match[2]; + var argument = getNamedPragmaArguments(pragma, args); + if (argument === "fail") + return; + pragmas.push({ name: name, args: { arguments: argument, range: range } }); + return; + } + function getNamedPragmaArguments(pragma, text) { + if (!text) + return {}; + if (!pragma.args) + return {}; + var args = text.split(/\s+/); + var argMap = {}; + for (var i = 0; i < pragma.args.length; i++) { + var argument = pragma.args[i]; + if (!args[i] && !argument.optional) { + return "fail"; + } + if (argument.captureSpan) { + return ts.Debug.fail("Capture spans not yet implemented for non-xml pragmas"); + } + argMap[argument.name] = args[i]; + } + return argMap; + } + function tagNamesAreEquivalent(lhs, rhs) { + if (lhs.kind !== rhs.kind) { + return false; + } + if (lhs.kind === 75) { + return lhs.escapedText === rhs.escapedText; + } + if (lhs.kind === 104) { + return true; + } + return lhs.name.escapedText === rhs.name.escapedText && + tagNamesAreEquivalent(lhs.expression, rhs.expression); + } + ts.tagNamesAreEquivalent = tagNamesAreEquivalent; +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.compileOnSaveCommandLineOption = { name: "compileOnSave", type: "boolean" }; + var libEntries = [ + ["es5", "lib.es5.d.ts"], + ["es6", "lib.es2015.d.ts"], + ["es2015", "lib.es2015.d.ts"], + ["es7", "lib.es2016.d.ts"], + ["es2016", "lib.es2016.d.ts"], + ["es2017", "lib.es2017.d.ts"], + ["es2018", "lib.es2018.d.ts"], + ["es2019", "lib.es2019.d.ts"], + ["es2020", "lib.es2020.d.ts"], + ["esnext", "lib.esnext.d.ts"], + ["dom", "lib.dom.d.ts"], + ["dom.iterable", "lib.dom.iterable.d.ts"], + ["webworker", "lib.webworker.d.ts"], + ["webworker.importscripts", "lib.webworker.importscripts.d.ts"], + ["scripthost", "lib.scripthost.d.ts"], + ["es2015.core", "lib.es2015.core.d.ts"], + ["es2015.collection", "lib.es2015.collection.d.ts"], + ["es2015.generator", "lib.es2015.generator.d.ts"], + ["es2015.iterable", "lib.es2015.iterable.d.ts"], + ["es2015.promise", "lib.es2015.promise.d.ts"], + ["es2015.proxy", "lib.es2015.proxy.d.ts"], + ["es2015.reflect", "lib.es2015.reflect.d.ts"], + ["es2015.symbol", "lib.es2015.symbol.d.ts"], + ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"], + ["es2016.array.include", "lib.es2016.array.include.d.ts"], + ["es2017.object", "lib.es2017.object.d.ts"], + ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"], + ["es2017.string", "lib.es2017.string.d.ts"], + ["es2017.intl", "lib.es2017.intl.d.ts"], + ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"], + ["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"], + ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["es2018.intl", "lib.es2018.intl.d.ts"], + ["es2018.promise", "lib.es2018.promise.d.ts"], + ["es2018.regexp", "lib.es2018.regexp.d.ts"], + ["es2019.array", "lib.es2019.array.d.ts"], + ["es2019.object", "lib.es2019.object.d.ts"], + ["es2019.string", "lib.es2019.string.d.ts"], + ["es2019.symbol", "lib.es2019.symbol.d.ts"], + ["es2020.bigint", "lib.es2020.bigint.d.ts"], + ["es2020.promise", "lib.es2020.promise.d.ts"], + ["es2020.string", "lib.es2020.string.d.ts"], + ["es2020.symbol.wellknown", "lib.es2020.symbol.wellknown.d.ts"], + ["esnext.array", "lib.es2019.array.d.ts"], + ["esnext.symbol", "lib.es2019.symbol.d.ts"], + ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["esnext.intl", "lib.esnext.intl.d.ts"], + ["esnext.bigint", "lib.es2020.bigint.d.ts"] + ]; + ts.libs = libEntries.map(function (entry) { return entry[0]; }); + ts.libMap = ts.createMapFromEntries(libEntries); + ts.optionsForWatch = [ + { + name: "watchFile", + type: ts.createMapFromTemplate({ + fixedpollinginterval: ts.WatchFileKind.FixedPollingInterval, + prioritypollinginterval: ts.WatchFileKind.PriorityPollingInterval, + dynamicprioritypolling: ts.WatchFileKind.DynamicPriorityPolling, + usefsevents: ts.WatchFileKind.UseFsEvents, + usefseventsonparentdirectory: ts.WatchFileKind.UseFsEventsOnParentDirectory, + }), + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_UseFsEvents_UseFsEventsOnParentDirectory, + }, + { + name: "watchDirectory", + type: ts.createMapFromTemplate({ + usefsevents: ts.WatchDirectoryKind.UseFsEvents, + fixedpollinginterval: ts.WatchDirectoryKind.FixedPollingInterval, + dynamicprioritypolling: ts.WatchDirectoryKind.DynamicPriorityPolling, + }), + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling, + }, + { + name: "fallbackPolling", + type: ts.createMapFromTemplate({ + fixedinterval: ts.PollingWatchKind.FixedInterval, + priorityinterval: ts.PollingWatchKind.PriorityInterval, + dynamicpriority: ts.PollingWatchKind.DynamicPriority, + }), + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority, + }, + { + name: "synchronousWatchDirectory", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, + }, + ]; + ts.commonOptionsWithBuild = [ + { + name: "help", + shortName: "h", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Print_this_message, + }, + { + name: "help", + shortName: "?", + type: "boolean" + }, + { + name: "watch", + shortName: "w", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Watch_input_files, + }, + { + name: "preserveWatchOutput", + type: "boolean", + showInSimplifiedHelpView: false, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen, + }, + { + name: "listFiles", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Print_names_of_files_part_of_the_compilation + }, + { + name: "listEmittedFiles", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Print_names_of_generated_files_part_of_the_compilation + }, + { + name: "pretty", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental + }, + { + name: "traceResolution", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Enable_tracing_of_the_name_resolution_process + }, + { + name: "diagnostics", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Show_diagnostic_information + }, + { + name: "extendedDiagnostics", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Show_verbose_diagnostic_information + }, + { + name: "generateCpuProfile", + type: "string", + isFilePath: true, + paramType: ts.Diagnostics.FILE_OR_DIRECTORY, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Generates_a_CPU_profile + }, + { + name: "incremental", + shortName: "i", + type: "boolean", + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Enable_incremental_compilation, + transpileOptionValue: undefined + }, + { + name: "assumeChangesOnlyAffectDirectDependencies", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it + }, + { + name: "locale", + type: "string", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.The_locale_used_when_displaying_messages_to_the_user_e_g_en_us + }, + ]; + ts.optionDeclarations = __spreadArrays(ts.commonOptionsWithBuild, [ + { + name: "all", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Show_all_compiler_options, + }, + { + name: "version", + shortName: "v", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Print_the_compiler_s_version, + }, + { + name: "init", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file, + }, + { + name: "project", + shortName: "p", + type: "string", + isFilePath: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + paramType: ts.Diagnostics.FILE_OR_DIRECTORY, + description: ts.Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json, + }, + { + name: "build", + type: "boolean", + shortName: "b", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date + }, + { + name: "showConfig", + type: "boolean", + category: ts.Diagnostics.Command_line_Options, + isCommandLineOnly: true, + description: ts.Diagnostics.Print_the_final_configuration_instead_of_building + }, + { + name: "listFilesOnly", + type: "boolean", + category: ts.Diagnostics.Command_line_Options, + affectsSemanticDiagnostics: true, + affectsEmit: true, + isCommandLineOnly: true, + description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing + }, + { + name: "target", + shortName: "t", + type: ts.createMapFromTemplate({ + es3: 0, + es5: 1, + es6: 2, + es2015: 2, + es2016: 3, + es2017: 4, + es2018: 5, + es2019: 6, + es2020: 7, + esnext: 99, + }), + affectsSourceFile: true, + affectsModuleResolution: true, + affectsEmit: true, + paramType: ts.Diagnostics.VERSION, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT, + }, + { + name: "module", + shortName: "m", + type: ts.createMapFromTemplate({ + none: ts.ModuleKind.None, + commonjs: ts.ModuleKind.CommonJS, + amd: ts.ModuleKind.AMD, + system: ts.ModuleKind.System, + umd: ts.ModuleKind.UMD, + es6: ts.ModuleKind.ES2015, + es2015: ts.ModuleKind.ES2015, + es2020: ts.ModuleKind.ES2020, + esnext: ts.ModuleKind.ESNext + }), + affectsModuleResolution: true, + affectsEmit: true, + paramType: ts.Diagnostics.KIND, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext, + }, + { + name: "lib", + type: "list", + element: { + name: "lib", + type: ts.libMap + }, + affectsModuleResolution: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_library_files_to_be_included_in_the_compilation, + transpileOptionValue: undefined + }, + { + name: "allowJs", + type: "boolean", + affectsModuleResolution: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Allow_javascript_files_to_be_compiled + }, + { + name: "checkJs", + type: "boolean", + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Report_errors_in_js_files + }, + { + name: "jsx", + type: ts.createMapFromTemplate({ + "preserve": 1, + "react-native": 3, + "react": 2 + }), + affectsSourceFile: true, + paramType: ts.Diagnostics.KIND, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_or_react, + }, + { + name: "declaration", + shortName: "d", + type: "boolean", + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Generates_corresponding_d_ts_file, + transpileOptionValue: undefined + }, + { + name: "declarationMap", + type: "boolean", + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Generates_a_sourcemap_for_each_corresponding_d_ts_file, + transpileOptionValue: undefined + }, + { + name: "emitDeclarationOnly", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Only_emit_d_ts_declaration_files, + transpileOptionValue: undefined + }, + { + name: "sourceMap", + type: "boolean", + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Generates_corresponding_map_file, + }, + { + name: "outFile", + type: "string", + affectsEmit: true, + isFilePath: true, + paramType: ts.Diagnostics.FILE, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, + transpileOptionValue: undefined + }, + { + name: "outDir", + type: "string", + affectsEmit: true, + isFilePath: true, + paramType: ts.Diagnostics.DIRECTORY, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Redirect_output_structure_to_the_directory, + }, + { + name: "rootDir", + type: "string", + affectsEmit: true, + isFilePath: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir, + }, + { + name: "composite", + type: "boolean", + affectsEmit: true, + isTSConfigOnly: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Enable_project_compilation, + transpileOptionValue: undefined + }, + { + name: "tsBuildInfoFile", + type: "string", + affectsEmit: true, + isFilePath: true, + paramType: ts.Diagnostics.FILE, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_file_to_store_incremental_compilation_information, + transpileOptionValue: undefined + }, + { + name: "removeComments", + type: "boolean", + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Do_not_emit_comments_to_output, + }, + { + name: "noEmit", + type: "boolean", + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Do_not_emit_outputs, + transpileOptionValue: undefined + }, + { + name: "importHelpers", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Import_emit_helpers_from_tslib + }, + { + name: "importsNotUsedAsValues", + type: ts.createMapFromTemplate({ + remove: 0, + preserve: 1, + error: 2 + }), + affectsEmit: true, + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types + }, + { + name: "downlevelIteration", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3 + }, + { + name: "isolatedModules", + type: "boolean", + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule, + transpileOptionValue: true + }, + { + name: "strict", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Enable_all_strict_type_checking_options + }, + { + name: "noImplicitAny", + type: "boolean", + affectsSemanticDiagnostics: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type + }, + { + name: "strictNullChecks", + type: "boolean", + affectsSemanticDiagnostics: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Enable_strict_null_checks + }, + { + name: "strictFunctionTypes", + type: "boolean", + affectsSemanticDiagnostics: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Enable_strict_checking_of_function_types + }, + { + name: "strictBindCallApply", + type: "boolean", + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Enable_strict_bind_call_and_apply_methods_on_functions + }, + { + name: "strictPropertyInitialization", + type: "boolean", + affectsSemanticDiagnostics: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Enable_strict_checking_of_property_initialization_in_classes + }, + { + name: "noImplicitThis", + type: "boolean", + affectsSemanticDiagnostics: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type, + }, + { + name: "alwaysStrict", + type: "boolean", + affectsSourceFile: true, + strictFlag: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Strict_Type_Checking_Options, + description: ts.Diagnostics.Parse_in_strict_mode_and_emit_use_strict_for_each_source_file + }, + { + name: "noUnusedLocals", + type: "boolean", + affectsSemanticDiagnostics: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Additional_Checks, + description: ts.Diagnostics.Report_errors_on_unused_locals, + }, + { + name: "noUnusedParameters", + type: "boolean", + affectsSemanticDiagnostics: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Additional_Checks, + description: ts.Diagnostics.Report_errors_on_unused_parameters, + }, + { + name: "noImplicitReturns", + type: "boolean", + affectsSemanticDiagnostics: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Additional_Checks, + description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value + }, + { + name: "noFallthroughCasesInSwitch", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Additional_Checks, + description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement + }, + { + name: "moduleResolution", + type: ts.createMapFromTemplate({ + node: ts.ModuleResolutionKind.NodeJs, + classic: ts.ModuleResolutionKind.Classic, + }), + affectsModuleResolution: true, + paramType: ts.Diagnostics.STRATEGY, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6, + }, + { + name: "baseUrl", + type: "string", + affectsModuleResolution: true, + isFilePath: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Base_directory_to_resolve_non_absolute_module_names + }, + { + name: "paths", + type: "object", + affectsModuleResolution: true, + isTSConfigOnly: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl, + transpileOptionValue: undefined + }, + { + name: "rootDirs", + type: "list", + isTSConfigOnly: true, + element: { + name: "rootDirs", + type: "string", + isFilePath: true + }, + affectsModuleResolution: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime, + transpileOptionValue: undefined + }, + { + name: "typeRoots", + type: "list", + element: { + name: "typeRoots", + type: "string", + isFilePath: true + }, + affectsModuleResolution: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.List_of_folders_to_include_type_definitions_from + }, + { + name: "types", + type: "list", + element: { + name: "types", + type: "string" + }, + affectsModuleResolution: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Type_declaration_files_to_be_included_in_compilation, + transpileOptionValue: undefined + }, + { + name: "allowSyntheticDefaultImports", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking + }, + { + name: "esModuleInterop", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports + }, + { + name: "preserveSymlinks", + type: "boolean", + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Do_not_resolve_the_real_path_of_symlinks, + }, + { + name: "allowUmdGlobalAccess", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Module_Resolution_Options, + description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules, + }, + { + name: "sourceRoot", + type: "string", + affectsEmit: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Source_Map_Options, + description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations, + }, + { + name: "mapRoot", + type: "string", + affectsEmit: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Source_Map_Options, + description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations, + }, + { + name: "inlineSourceMap", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Source_Map_Options, + description: ts.Diagnostics.Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file + }, + { + name: "inlineSources", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Source_Map_Options, + description: ts.Diagnostics.Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set + }, + { + name: "experimentalDecorators", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Experimental_Options, + description: ts.Diagnostics.Enables_experimental_support_for_ES7_decorators + }, + { + name: "emitDecoratorMetadata", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + category: ts.Diagnostics.Experimental_Options, + description: ts.Diagnostics.Enables_experimental_support_for_emitting_type_metadata_for_decorators + }, + { + name: "jsxFactory", + type: "string", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h + }, + { + name: "resolveJsonModule", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Include_modules_imported_with_json_extension + }, + { + name: "out", + type: "string", + affectsEmit: true, + isFilePath: false, + category: ts.Diagnostics.Advanced_Options, + paramType: ts.Diagnostics.FILE, + description: ts.Diagnostics.Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file, + transpileOptionValue: undefined + }, + { + name: "reactNamespace", + type: "string", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit + }, + { + name: "skipDefaultLibCheck", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files + }, + { + name: "charset", + type: "string", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.The_character_set_of_the_input_files + }, + { + name: "emitBOM", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files + }, + { + name: "newLine", + type: ts.createMapFromTemplate({ + crlf: 0, + lf: 1 + }), + affectsEmit: true, + paramType: ts.Diagnostics.NEWLINE, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix, + }, + { + name: "noErrorTruncation", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_truncate_error_messages + }, + { + name: "noLib", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_include_the_default_library_file_lib_d_ts, + transpileOptionValue: true + }, + { + name: "noResolve", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files, + transpileOptionValue: true + }, + { + name: "stripInternal", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation, + }, + { + name: "disableSizeLimit", + type: "boolean", + affectsSourceFile: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Disable_size_limitations_on_JavaScript_projects + }, + { + name: "disableSourceOfProjectReferenceRedirect", + type: "boolean", + isTSConfigOnly: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects + }, + { + name: "disableSolutionSearching", + type: "boolean", + isTSConfigOnly: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Disable_solution_searching_for_this_project + }, + { + name: "noImplicitUseStrict", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_emit_use_strict_directives_in_module_output + }, + { + name: "noEmitHelpers", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_generate_custom_helper_functions_like_extends_in_compiled_output + }, + { + name: "noEmitOnError", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported, + transpileOptionValue: undefined + }, + { + name: "preserveConstEnums", + type: "boolean", + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code + }, + { + name: "declarationDir", + type: "string", + affectsEmit: true, + isFilePath: true, + paramType: ts.Diagnostics.DIRECTORY, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Output_directory_for_generated_declaration_files, + transpileOptionValue: undefined + }, + { + name: "skipLibCheck", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Skip_type_checking_of_declaration_files, + }, + { + name: "allowUnusedLabels", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_report_errors_on_unused_labels + }, + { + name: "allowUnreachableCode", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code + }, + { + name: "suppressExcessPropertyErrors", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Suppress_excess_property_checks_for_object_literals, + }, + { + name: "suppressImplicitAnyIndexErrors", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures, + }, + { + name: "forceConsistentCasingInFileNames", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file + }, + { + name: "maxNodeModuleJsDepth", + type: "number", + affectsModuleResolution: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files + }, + { + name: "noStrictGenericChecks", + type: "boolean", + affectsSemanticDiagnostics: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types, + }, + { + name: "useDefineForClassFields", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Emit_class_fields_with_Define_instead_of_Set, + }, + { + name: "keyofStringsOnly", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols, + }, + { + name: "plugins", + type: "list", + isTSConfigOnly: true, + element: { + name: "plugin", + type: "object" + }, + description: ts.Diagnostics.List_of_language_service_plugins + }, + ]); + ts.semanticDiagnosticsOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsSemanticDiagnostics; }); + ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; }); + ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; }); + ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) { + return !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics; + }); + ts.transpileOptionValueCompilerOptions = ts.optionDeclarations.filter(function (option) { + return ts.hasProperty(option, "transpileOptionValue"); + }); + ts.buildOpts = __spreadArrays(ts.commonOptionsWithBuild, [ + { + name: "verbose", + shortName: "v", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Enable_verbose_logging, + type: "boolean" + }, + { + name: "dry", + shortName: "d", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean, + type: "boolean" + }, + { + name: "force", + shortName: "f", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date, + type: "boolean" + }, + { + name: "clean", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Delete_the_outputs_of_all_projects, + type: "boolean" + } + ]); + ts.typeAcquisitionDeclarations = [ + { + name: "enableAutoDiscovery", + type: "boolean", + }, + { + name: "enable", + type: "boolean", + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + } + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + } + } + ]; + function createOptionNameMap(optionDeclarations) { + var optionsNameMap = ts.createMap(); + var shortOptionNames = ts.createMap(); + ts.forEach(optionDeclarations, function (option) { + optionsNameMap.set(option.name.toLowerCase(), option); + if (option.shortName) { + shortOptionNames.set(option.shortName, option.name); + } + }); + return { optionsNameMap: optionsNameMap, shortOptionNames: shortOptionNames }; + } + ts.createOptionNameMap = createOptionNameMap; + var optionsNameMapCache; + function getOptionsNameMap() { + return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(ts.optionDeclarations)); + } + ts.getOptionsNameMap = getOptionsNameMap; + ts.defaultInitCompilerOptions = { + module: ts.ModuleKind.CommonJS, + target: 1, + strict: true, + esModuleInterop: true, + forceConsistentCasingInFileNames: true + }; + function convertEnableAutoDiscoveryToEnable(typeAcquisition) { + if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) { + return { + enable: typeAcquisition.enableAutoDiscovery, + include: typeAcquisition.include || [], + exclude: typeAcquisition.exclude || [] + }; + } + return typeAcquisition; + } + ts.convertEnableAutoDiscoveryToEnable = convertEnableAutoDiscoveryToEnable; + function createCompilerDiagnosticForInvalidCustomType(opt) { + return createDiagnosticForInvalidCustomType(opt, ts.createCompilerDiagnostic); + } + ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType; + function createDiagnosticForInvalidCustomType(opt, createDiagnostic) { + var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'" + key + "'"; }).join(", "); + return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--" + opt.name, namesOfType); + } + function parseCustomTypeOption(opt, value, errors) { + return convertJsonOptionOfCustomType(opt, trimString(value || ""), errors); + } + ts.parseCustomTypeOption = parseCustomTypeOption; + function parseListTypeOption(opt, value, errors) { + if (value === void 0) { value = ""; } + value = trimString(value); + if (ts.startsWith(value, "-")) { + return undefined; + } + if (value === "") { + return []; + } + var values = value.split(","); + switch (opt.element.type) { + case "number": + return ts.map(values, parseInt); + case "string": + return ts.map(values, function (v) { return v || ""; }); + default: + return ts.mapDefined(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); }); + } + } + ts.parseListTypeOption = parseListTypeOption; + function getOptionName(option) { + return option.name; + } + function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) { + var possibleOption = ts.getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName); + return possibleOption ? + createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : + createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption); + } + function parseCommandLineWorker(diagnostics, commandLine, readFile) { + var options = {}; + var watchOptions; + var fileNames = []; + var errors = []; + parseStrings(commandLine); + return { + options: options, + watchOptions: watchOptions, + fileNames: fileNames, + errors: errors + }; + function parseStrings(args) { + var i = 0; + while (i < args.length) { + var s = args[i]; + i++; + if (s.charCodeAt(0) === 64) { + parseResponseFile(s.slice(1)); + } + else if (s.charCodeAt(0) === 45) { + var inputOptionName = s.slice(s.charCodeAt(1) === 45 ? 2 : 1); + var opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, true); + if (opt) { + i = parseOptionValue(args, i, diagnostics, opt, options, errors); + } + else { + var watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, true); + if (watchOpt) { + i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors); + } + else { + errors.push(createUnknownOptionError(inputOptionName, diagnostics, ts.createCompilerDiagnostic, s)); + } + } + } + else { + fileNames.push(s); + } + } + } + function parseResponseFile(fileName) { + var text = readFile ? readFile(fileName) : ts.sys.readFile(fileName); + if (!text) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, fileName)); + return; + } + var args = []; + var pos = 0; + while (true) { + while (pos < text.length && text.charCodeAt(pos) <= 32) + pos++; + if (pos >= text.length) + break; + var start = pos; + if (text.charCodeAt(start) === 34) { + pos++; + while (pos < text.length && text.charCodeAt(pos) !== 34) + pos++; + if (pos < text.length) { + args.push(text.substring(start + 1, pos)); + pos++; + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName)); + } + } + else { + while (text.charCodeAt(pos) > 32) + pos++; + args.push(text.substring(start, pos)); + } + } + parseStrings(args); + } + } + ts.parseCommandLineWorker = parseCommandLineWorker; + function parseOptionValue(args, i, diagnostics, opt, options, errors) { + if (opt.isTSConfigOnly) { + var optValue = args[i]; + if (optValue === "null") { + options[opt.name] = undefined; + i++; + } + else if (opt.type === "boolean") { + if (optValue === "false") { + options[opt.name] = false; + i++; + } + else { + if (optValue === "true") + i++; + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name)); + } + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name)); + if (optValue && !ts.startsWith(optValue, "-")) + i++; + } + } + else { + if (!args[i] && opt.type !== "boolean") { + errors.push(ts.createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt))); + } + if (args[i] !== "null") { + switch (opt.type) { + case "number": + options[opt.name] = parseInt(args[i]); + i++; + break; + case "boolean": + var optValue = args[i]; + options[opt.name] = optValue !== "false"; + if (optValue === "false" || optValue === "true") { + i++; + } + break; + case "string": + options[opt.name] = args[i] || ""; + i++; + break; + case "list": + var result = parseListTypeOption(opt, args[i], errors); + options[opt.name] = result || []; + if (result) { + i++; + } + break; + default: + options[opt.name] = parseCustomTypeOption(opt, args[i], errors); + i++; + break; + } + } + else { + options[opt.name] = undefined; + i++; + } + } + return i; + } + ts.compilerOptionsDidYouMeanDiagnostics = { + getOptionsNameMap: getOptionsNameMap, + optionDeclarations: ts.optionDeclarations, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_compiler_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_compiler_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Compiler_option_0_expects_an_argument + }; + function parseCommandLine(commandLine, readFile) { + return parseCommandLineWorker(ts.compilerOptionsDidYouMeanDiagnostics, commandLine, readFile); + } + ts.parseCommandLine = parseCommandLine; + function getOptionFromName(optionName, allowShort) { + return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort); + } + ts.getOptionFromName = getOptionFromName; + function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort) { + if (allowShort === void 0) { allowShort = false; } + optionName = optionName.toLowerCase(); + var _a = getOptionNameMap(), optionsNameMap = _a.optionsNameMap, shortOptionNames = _a.shortOptionNames; + if (allowShort) { + var short = shortOptionNames.get(optionName); + if (short !== undefined) { + optionName = short; + } + } + return optionsNameMap.get(optionName); + } + var buildOptionsNameMapCache; + function getBuildOptionsNameMap() { + return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(ts.buildOpts)); + } + var buildOptionsDidYouMeanDiagnostics = { + getOptionsNameMap: getBuildOptionsNameMap, + optionDeclarations: ts.buildOpts, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_build_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_build_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Build_option_0_requires_a_value_of_type_1 + }; + function parseBuildCommand(args) { + var _a = parseCommandLineWorker(buildOptionsDidYouMeanDiagnostics, args), options = _a.options, watchOptions = _a.watchOptions, projects = _a.fileNames, errors = _a.errors; + var buildOptions = options; + if (projects.length === 0) { + projects.push("."); + } + if (buildOptions.clean && buildOptions.force) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force")); + } + if (buildOptions.clean && buildOptions.verbose) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose")); + } + if (buildOptions.clean && buildOptions.watch) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch")); + } + if (buildOptions.watch && buildOptions.dry) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry")); + } + return { buildOptions: buildOptions, watchOptions: watchOptions, projects: projects, errors: errors }; + } + ts.parseBuildCommand = parseBuildCommand; + function getDiagnosticText(_message) { + var _args = []; + for (var _i = 1; _i < arguments.length; _i++) { + _args[_i - 1] = arguments[_i]; + } + var diagnostic = ts.createCompilerDiagnostic.apply(undefined, arguments); + return diagnostic.messageText; + } + ts.getDiagnosticText = getDiagnosticText; + function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend) { + var configFileText; + try { + configFileText = host.readFile(configFileName); + } + catch (e) { + var error = ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message); + host.onUnRecoverableConfigFileDiagnostic(error); + return undefined; + } + if (!configFileText) { + var error = ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, configFileName); + host.onUnRecoverableConfigFileDiagnostic(error); + return undefined; + } + var result = ts.parseJsonText(configFileName, configFileText); + var cwd = host.getCurrentDirectory(); + result.path = ts.toPath(configFileName, cwd, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames)); + result.resolvedPath = result.path; + result.originalFileName = result.fileName; + return parseJsonSourceFileConfigFileContent(result, host, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), cwd), optionsToExtend, ts.getNormalizedAbsolutePath(configFileName, cwd), undefined, undefined, extendedConfigCache, watchOptionsToExtend); + } + ts.getParsedCommandLineOfConfigFile = getParsedCommandLineOfConfigFile; + function readConfigFile(fileName, readFile) { + var textOrDiagnostic = tryReadFile(fileName, readFile); + return ts.isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic }; + } + ts.readConfigFile = readConfigFile; + function parseConfigFileTextToJson(fileName, jsonText) { + var jsonSourceFile = ts.parseJsonText(fileName, jsonText); + return { + config: convertToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics), + error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined + }; + } + ts.parseConfigFileTextToJson = parseConfigFileTextToJson; + function readJsonConfigFile(fileName, readFile) { + var textOrDiagnostic = tryReadFile(fileName, readFile); + return ts.isString(textOrDiagnostic) ? ts.parseJsonText(fileName, textOrDiagnostic) : { parseDiagnostics: [textOrDiagnostic] }; + } + ts.readJsonConfigFile = readJsonConfigFile; + function tryReadFile(fileName, readFile) { + var text; + try { + text = readFile(fileName); + } + catch (e) { + return ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message); + } + return text === undefined ? ts.createCompilerDiagnostic(ts.Diagnostics.The_specified_path_does_not_exist_Colon_0, fileName) : text; + } + function commandLineOptionsToMap(options) { + return ts.arrayToMap(options, getOptionName); + } + var typeAcquisitionDidYouMeanDiagnostics = { + optionDeclarations: ts.typeAcquisitionDeclarations, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1, + }; + var watchOptionsNameMapCache; + function getWatchOptionsNameMap() { + return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(ts.optionsForWatch)); + } + var watchOptionsDidYouMeanDiagnostics = { + getOptionsNameMap: getWatchOptionsNameMap, + optionDeclarations: ts.optionsForWatch, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_watch_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_watch_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Watch_option_0_requires_a_value_of_type_1 + }; + var commandLineCompilerOptionsMapCache; + function getCommandLineCompilerOptionsMap() { + return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(ts.optionDeclarations)); + } + var commandLineWatchOptionsMapCache; + function getCommandLineWatchOptionsMap() { + return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(ts.optionsForWatch)); + } + var commandLineTypeAcquisitionMapCache; + function getCommandLineTypeAcquisitionMap() { + return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(ts.typeAcquisitionDeclarations)); + } + var _tsconfigRootOptions; + function getTsconfigRootOptionsMap() { + if (_tsconfigRootOptions === undefined) { + _tsconfigRootOptions = { + name: undefined, + type: "object", + elementOptions: commandLineOptionsToMap([ + { + name: "compilerOptions", + type: "object", + elementOptions: getCommandLineCompilerOptionsMap(), + extraKeyDiagnostics: ts.compilerOptionsDidYouMeanDiagnostics, + }, + { + name: "watchOptions", + type: "object", + elementOptions: getCommandLineWatchOptionsMap(), + extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics, + }, + { + name: "typingOptions", + type: "object", + elementOptions: getCommandLineTypeAcquisitionMap(), + extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics, + }, + { + name: "typeAcquisition", + type: "object", + elementOptions: getCommandLineTypeAcquisitionMap(), + extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics + }, + { + name: "extends", + type: "string" + }, + { + name: "references", + type: "list", + element: { + name: "references", + type: "object" + } + }, + { + name: "files", + type: "list", + element: { + name: "files", + type: "string" + } + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + } + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + } + }, + ts.compileOnSaveCommandLineOption + ]) + }; + } + return _tsconfigRootOptions; + } + function convertToObject(sourceFile, errors) { + return convertToObjectWorker(sourceFile, errors, true, undefined, undefined); + } + ts.convertToObject = convertToObject; + function convertToObjectWorker(sourceFile, errors, returnValue, knownRootOptions, jsonConversionNotifier) { + if (!sourceFile.statements.length) { + return returnValue ? {} : undefined; + } + return convertPropertyValueToJson(sourceFile.statements[0].expression, knownRootOptions); + function isRootOptionMap(knownOptions) { + return knownRootOptions && knownRootOptions.elementOptions === knownOptions; + } + function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) { + var result = returnValue ? {} : undefined; + var _loop_3 = function (element) { + if (element.kind !== 281) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element, ts.Diagnostics.Property_assignment_expected)); + return "continue"; + } + if (element.questionToken) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")); + } + if (!isDoubleQuotedString(element.name)) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, ts.Diagnostics.String_literal_with_double_quotes_expected)); + } + var textOfKey = ts.getTextOfPropertyName(element.name); + var keyText = textOfKey && ts.unescapeLeadingUnderscores(textOfKey); + var option = keyText && knownOptions ? knownOptions.get(keyText) : undefined; + if (keyText && extraKeyDiagnostics && !option) { + if (knownOptions) { + errors.push(createUnknownOptionError(keyText, extraKeyDiagnostics, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1); })); + } + else { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText)); + } + } + var value = convertPropertyValueToJson(element.initializer, option); + if (typeof keyText !== "undefined") { + if (returnValue) { + result[keyText] = value; + } + if (jsonConversionNotifier && + (parentOption || isRootOptionMap(knownOptions))) { + var isValidOptionValue = isCompilerOptionsValue(option, value); + if (parentOption) { + if (isValidOptionValue) { + jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value); + } + } + else if (isRootOptionMap(knownOptions)) { + if (isValidOptionValue) { + jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer); + } + else if (!option) { + jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer); + } + } + } + } + }; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var element = _a[_i]; + _loop_3(element); + } + return result; + } + function convertArrayLiteralExpressionToJson(elements, elementOption) { + if (!returnValue) { + return elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); }); + } + return ts.filter(elements.map(function (element) { return convertPropertyValueToJson(element, elementOption); }), function (v) { return v !== undefined; }); + } + function convertPropertyValueToJson(valueExpression, option) { + switch (valueExpression.kind) { + case 106: + reportInvalidOptionValue(option && option.type !== "boolean"); + return true; + case 91: + reportInvalidOptionValue(option && option.type !== "boolean"); + return false; + case 100: + reportInvalidOptionValue(option && option.name === "extends"); + return null; + case 10: + if (!isDoubleQuotedString(valueExpression)) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.String_literal_with_double_quotes_expected)); + } + reportInvalidOptionValue(option && (ts.isString(option.type) && option.type !== "string")); + var text = valueExpression.text; + if (option && !ts.isString(option.type)) { + var customOption = option; + if (!customOption.type.has(text.toLowerCase())) { + errors.push(createDiagnosticForInvalidCustomType(customOption, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1); })); + } + } + return text; + case 8: + reportInvalidOptionValue(option && option.type !== "number"); + return Number(valueExpression.text); + case 207: + if (valueExpression.operator !== 40 || valueExpression.operand.kind !== 8) { + break; + } + reportInvalidOptionValue(option && option.type !== "number"); + return -Number(valueExpression.operand.text); + case 193: + reportInvalidOptionValue(option && option.type !== "object"); + var objectLiteralExpression = valueExpression; + if (option) { + var _a = option, elementOptions = _a.elementOptions, extraKeyDiagnostics = _a.extraKeyDiagnostics, optionName = _a.name; + return convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName); + } + else { + return convertObjectLiteralExpressionToJson(objectLiteralExpression, undefined, undefined, undefined); + } + case 192: + reportInvalidOptionValue(option && option.type !== "list"); + return convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element); + } + if (option) { + reportInvalidOptionValue(true); + } + else { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal)); + } + return undefined; + function reportInvalidOptionValue(isError) { + if (isError) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option))); + } + } + } + function isDoubleQuotedString(node) { + return ts.isStringLiteral(node) && ts.isStringDoubleQuoted(node, sourceFile); + } + } + ts.convertToObjectWorker = convertToObjectWorker; + function getCompilerOptionValueTypeString(option) { + return option.type === "list" ? + "Array" : + ts.isString(option.type) ? option.type : "string"; + } + function isCompilerOptionsValue(option, value) { + if (option) { + if (isNullOrUndefined(value)) + return true; + if (option.type === "list") { + return ts.isArray(value); + } + var expectedType = ts.isString(option.type) ? option.type : "string"; + return typeof value === expectedType; + } + return false; + } + function convertToTSConfig(configParseResult, configFileName, host) { + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + var files = ts.map(ts.filter(configParseResult.fileNames, (!configParseResult.configFileSpecs || !configParseResult.configFileSpecs.validatedIncludeSpecs) ? function (_) { return true; } : matchesSpecs(configFileName, configParseResult.configFileSpecs.validatedIncludeSpecs, configParseResult.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); }); + var optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames }); + var watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions); + var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (configParseResult.configFileSpecs ? { + include: filterSameAsDefaultInclude(configParseResult.configFileSpecs.validatedIncludeSpecs), + exclude: configParseResult.configFileSpecs.validatedExcludeSpecs + } : {})), { compileOnSave: !!configParseResult.compileOnSave ? true : undefined }); + return config; + } + ts.convertToTSConfig = convertToTSConfig; + function optionMapToObject(optionMap) { + return __assign({}, ts.arrayFrom(optionMap.entries()).reduce(function (prev, cur) { + var _a; + return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a))); + }, {})); + } + function filterSameAsDefaultInclude(specs) { + if (!ts.length(specs)) + return undefined; + if (ts.length(specs) !== 1) + return specs; + if (specs[0] === "**/*") + return undefined; + return specs; + } + function matchesSpecs(path, includeSpecs, excludeSpecs, host) { + if (!includeSpecs) + return function (_) { return true; }; + var patterns = ts.getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory()); + var excludeRe = patterns.excludePattern && ts.getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames); + var includeRe = patterns.includeFilePattern && ts.getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames); + if (includeRe) { + if (excludeRe) { + return function (path) { return !(includeRe.test(path) && !excludeRe.test(path)); }; + } + return function (path) { return !includeRe.test(path); }; + } + if (excludeRe) { + return function (path) { return excludeRe.test(path); }; + } + return function (_) { return true; }; + } + function getCustomTypeMapOfCommandLineOption(optionDefinition) { + if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") { + return undefined; + } + else if (optionDefinition.type === "list") { + return getCustomTypeMapOfCommandLineOption(optionDefinition.element); + } + else { + return optionDefinition.type; + } + } + function getNameOfCompilerOptionValue(value, customTypeMap) { + return ts.forEachEntry(customTypeMap, function (mapValue, key) { + if (mapValue === value) { + return key; + } + }); + } + function serializeCompilerOptions(options, pathOptions) { + return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions); + } + function serializeWatchOptions(options) { + return serializeOptionBaseObject(options, getWatchOptionsNameMap()); + } + function serializeOptionBaseObject(options, _a, pathOptions) { + var optionsNameMap = _a.optionsNameMap; + var result = ts.createMap(); + var getCanonicalFileName = pathOptions && ts.createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames); + var _loop_4 = function (name) { + if (ts.hasProperty(options, name)) { + if (optionsNameMap.has(name) && optionsNameMap.get(name).category === ts.Diagnostics.Command_line_Options) { + return "continue"; + } + var value = options[name]; + var optionDefinition = optionsNameMap.get(name.toLowerCase()); + if (optionDefinition) { + var customTypeMap_1 = getCustomTypeMapOfCommandLineOption(optionDefinition); + if (!customTypeMap_1) { + if (pathOptions && optionDefinition.isFilePath) { + result.set(name, ts.getRelativePathFromFile(pathOptions.configFilePath, ts.getNormalizedAbsolutePath(value, ts.getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName)); + } + else { + result.set(name, value); + } + } + else { + if (optionDefinition.type === "list") { + result.set(name, value.map(function (element) { return getNameOfCompilerOptionValue(element, customTypeMap_1); })); + } + else { + result.set(name, getNameOfCompilerOptionValue(value, customTypeMap_1)); + } + } + } + } + }; + for (var name in options) { + _loop_4(name); + } + return result; + } + function generateTSConfig(options, fileNames, newLine) { + var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions); + var compilerOptionsMap = serializeCompilerOptions(compilerOptions); + return writeConfigurations(); + function getDefaultValueForOption(option) { + switch (option.type) { + case "number": + return 1; + case "boolean": + return true; + case "string": + return option.isFilePath ? "./" : ""; + case "list": + return []; + case "object": + return {}; + default: + var iterResult = option.type.keys().next(); + if (!iterResult.done) + return iterResult.value; + return ts.Debug.fail("Expected 'option.type' to have entries."); + } + } + function makePadding(paddingLength) { + return Array(paddingLength + 1).join(" "); + } + function isAllowedOption(_a) { + var category = _a.category, name = _a.name; + return category !== undefined + && category !== ts.Diagnostics.Command_line_Options + && (category !== ts.Diagnostics.Advanced_Options || compilerOptionsMap.has(name)); + } + function writeConfigurations() { + var categorizedOptions = ts.createMultiMap(); + for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) { + var option = optionDeclarations_1[_i]; + var category = option.category; + if (isAllowedOption(option)) { + categorizedOptions.add(ts.getLocaleSpecificMessage(category), option); + } + } + var marginLength = 0; + var seenKnownKeys = 0; + var nameColumn = []; + var descriptionColumn = []; + categorizedOptions.forEach(function (options, category) { + if (nameColumn.length !== 0) { + nameColumn.push(""); + descriptionColumn.push(""); + } + nameColumn.push("/* " + category + " */"); + descriptionColumn.push(""); + for (var _i = 0, options_1 = options; _i < options_1.length; _i++) { + var option = options_1[_i]; + var optionName = void 0; + if (compilerOptionsMap.has(option.name)) { + optionName = "\"" + option.name + "\": " + JSON.stringify(compilerOptionsMap.get(option.name)) + ((seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ","); + } + else { + optionName = "// \"" + option.name + "\": " + JSON.stringify(getDefaultValueForOption(option)) + ","; + } + nameColumn.push(optionName); + descriptionColumn.push("/* " + (option.description && ts.getLocaleSpecificMessage(option.description) || option.name) + " */"); + marginLength = Math.max(optionName.length, marginLength); + } + }); + var tab = makePadding(2); + var result = []; + result.push("{"); + result.push(tab + "\"compilerOptions\": {"); + for (var i = 0; i < nameColumn.length; i++) { + var optionName = nameColumn[i]; + var description = descriptionColumn[i]; + result.push(optionName && "" + tab + tab + optionName + (description && (makePadding(marginLength - optionName.length + 2) + description))); + } + if (fileNames.length) { + result.push(tab + "},"); + result.push(tab + "\"files\": ["); + for (var i = 0; i < fileNames.length; i++) { + result.push("" + tab + tab + JSON.stringify(fileNames[i]) + (i === fileNames.length - 1 ? "" : ",")); + } + result.push(tab + "]"); + } + else { + result.push(tab + "}"); + } + result.push("}"); + return result.join(newLine) + newLine; + } + } + ts.generateTSConfig = generateTSConfig; + function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) { + var result = {}; + var optionsNameMap = getOptionsNameMap().optionsNameMap; + for (var name in options) { + if (ts.hasProperty(options, name)) { + result[name] = convertToOptionValueWithAbsolutePaths(optionsNameMap.get(name.toLowerCase()), options[name], toAbsolutePath); + } + } + if (result.configFilePath) { + result.configFilePath = toAbsolutePath(result.configFilePath); + } + return result; + } + ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths; + function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) { + if (option && !isNullOrUndefined(value)) { + if (option.type === "list") { + var values = value; + if (option.element.isFilePath && values.length) { + return values.map(toAbsolutePath); + } + } + else if (option.isFilePath) { + return toAbsolutePath(value); + } + } + return value; + } + function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) { + return parseJsonConfigFileContentWorker(json, undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache); + } + ts.parseJsonConfigFileContent = parseJsonConfigFileContent; + function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) { + return parseJsonConfigFileContentWorker(undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache); + } + ts.parseJsonSourceFileConfigFileContent = parseJsonSourceFileConfigFileContent; + function setConfigFileInOptions(options, configFile) { + if (configFile) { + Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile }); + } + } + ts.setConfigFileInOptions = setConfigFileInOptions; + function isNullOrUndefined(x) { + return x === undefined || x === null; + } + function directoryOfCombinedPath(fileName, basePath) { + return ts.getDirectoryPath(ts.getNormalizedAbsolutePath(fileName, basePath)); + } + function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache) { + if (existingOptions === void 0) { existingOptions = {}; } + if (resolutionStack === void 0) { resolutionStack = []; } + if (extraFileExtensions === void 0) { extraFileExtensions = []; } + ts.Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined)); + var errors = []; + var parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache); + var raw = parsedConfig.raw; + var options = ts.extend(existingOptions, parsedConfig.options || {}); + var watchOptions = existingWatchOptions && parsedConfig.watchOptions ? + ts.extend(existingWatchOptions, parsedConfig.watchOptions) : + parsedConfig.watchOptions || existingWatchOptions; + options.configFilePath = configFileName && ts.normalizeSlashes(configFileName); + setConfigFileInOptions(options, sourceFile); + var projectReferences; + var _a = getFileNames(), fileNames = _a.fileNames, wildcardDirectories = _a.wildcardDirectories, spec = _a.spec; + return { + options: options, + watchOptions: watchOptions, + fileNames: fileNames, + projectReferences: projectReferences, + typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(), + raw: raw, + errors: errors, + wildcardDirectories: wildcardDirectories, + compileOnSave: !!raw.compileOnSave, + configFileSpecs: spec + }; + function getFileNames() { + var filesSpecs; + if (ts.hasProperty(raw, "files") && !isNullOrUndefined(raw.files)) { + if (ts.isArray(raw.files)) { + filesSpecs = raw.files; + var hasReferences = ts.hasProperty(raw, "references") && !isNullOrUndefined(raw.references); + var hasZeroOrNoReferences = !hasReferences || raw.references.length === 0; + var hasExtends = ts.hasProperty(raw, "extends"); + if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) { + if (sourceFile) { + var fileName = configFileName || "tsconfig.json"; + var diagnosticMessage = ts.Diagnostics.The_files_list_in_config_file_0_is_empty; + var nodeValue = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "files"), function (property) { return property.initializer; }); + var error = nodeValue + ? ts.createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName) + : ts.createCompilerDiagnostic(diagnosticMessage, fileName); + errors.push(error); + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json"); + } + } + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array"); + } + } + var includeSpecs; + if (ts.hasProperty(raw, "include") && !isNullOrUndefined(raw.include)) { + if (ts.isArray(raw.include)) { + includeSpecs = raw.include; + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "include", "Array"); + } + } + var excludeSpecs; + if (ts.hasProperty(raw, "exclude") && !isNullOrUndefined(raw.exclude)) { + if (ts.isArray(raw.exclude)) { + excludeSpecs = raw.exclude; + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "exclude", "Array"); + } + } + else if (raw.compilerOptions) { + var outDir = raw.compilerOptions.outDir; + var declarationDir = raw.compilerOptions.declarationDir; + if (outDir || declarationDir) { + excludeSpecs = [outDir, declarationDir].filter(function (d) { return !!d; }); + } + } + if (filesSpecs === undefined && includeSpecs === undefined) { + includeSpecs = ["**/*"]; + } + var result = matchFileNames(filesSpecs, includeSpecs, excludeSpecs, configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath, options, host, errors, extraFileExtensions, sourceFile); + if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles(raw), resolutionStack)) { + errors.push(getErrorForNoInputFiles(result.spec, configFileName)); + } + if (ts.hasProperty(raw, "references") && !isNullOrUndefined(raw.references)) { + if (ts.isArray(raw.references)) { + for (var _i = 0, _a = raw.references; _i < _a.length; _i++) { + var ref = _a[_i]; + if (typeof ref.path !== "string") { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string"); + } + else { + (projectReferences || (projectReferences = [])).push({ + path: ts.getNormalizedAbsolutePath(ref.path, basePath), + originalPath: ref.path, + prepend: ref.prepend, + circular: ref.circular + }); + } + } + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "references", "Array"); + } + } + return result; + } + function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) { + if (!sourceFile) { + errors.push(ts.createCompilerDiagnostic(message, arg0, arg1)); + } + } + } + function isErrorNoInputFiles(error) { + return error.code === ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code; + } + function getErrorForNoInputFiles(_a, configFileName) { + var includeSpecs = _a.includeSpecs, excludeSpecs = _a.excludeSpecs; + return ts.createCompilerDiagnostic(ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, configFileName || "tsconfig.json", JSON.stringify(includeSpecs || []), JSON.stringify(excludeSpecs || [])); + } + function shouldReportNoInputFiles(result, canJsonReportNoInutFiles, resolutionStack) { + return result.fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0); + } + function canJsonReportNoInutFiles(raw) { + return !ts.hasProperty(raw, "files") && !ts.hasProperty(raw, "references"); + } + ts.canJsonReportNoInutFiles = canJsonReportNoInutFiles; + function updateErrorForNoInputFiles(result, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) { + var existingErrors = configParseDiagnostics.length; + if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles)) { + configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName)); + } + else { + ts.filterMutate(configParseDiagnostics, function (error) { return !isErrorNoInputFiles(error); }); + } + return existingErrors !== configParseDiagnostics.length; + } + ts.updateErrorForNoInputFiles = updateErrorForNoInputFiles; + function isSuccessfulParsedTsconfig(value) { + return !!value.options; + } + function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) { + basePath = ts.normalizeSlashes(basePath); + var resolvedPath = ts.getNormalizedAbsolutePath(configFileName || "", basePath); + if (resolutionStack.indexOf(resolvedPath) >= 0) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArrays(resolutionStack, [resolvedPath]).join(" -> "))); + return { raw: json || convertToObject(sourceFile, errors) }; + } + var ownConfig = json ? + parseOwnConfigOfJson(json, host, basePath, configFileName, errors) : + parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors); + if (ownConfig.extendedConfigPath) { + resolutionStack = resolutionStack.concat([resolvedPath]); + var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache); + if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) { + var baseRaw_1 = extendedConfig.raw; + var raw_1 = ownConfig.raw; + var setPropertyInRawIfNotUndefined = function (propertyName) { + var value = raw_1[propertyName] || baseRaw_1[propertyName]; + if (value) { + raw_1[propertyName] = value; + } + }; + setPropertyInRawIfNotUndefined("include"); + setPropertyInRawIfNotUndefined("exclude"); + setPropertyInRawIfNotUndefined("files"); + if (raw_1.compileOnSave === undefined) { + raw_1.compileOnSave = baseRaw_1.compileOnSave; + } + ownConfig.options = ts.assign({}, extendedConfig.options, ownConfig.options); + ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ? + ts.assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) : + ownConfig.watchOptions || extendedConfig.watchOptions; + } + } + return ownConfig; + } + function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) { + if (ts.hasProperty(json, "excludes")) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude)); + } + var options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName); + var typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName); + var watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors); + json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors); + var extendedConfigPath; + if (json.extends) { + if (!ts.isString(json.extends)) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string")); + } + else { + var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath; + extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, ts.createCompilerDiagnostic); + } + } + return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath }; + } + function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) { + var options = getDefaultCompilerOptions(configFileName); + var typeAcquisition, typingOptionstypeAcquisition; + var watchOptions; + var extendedConfigPath; + var optionsIterator = { + onSetValidOptionKeyValueInParent: function (parentOption, option, value) { + var currentOption; + switch (parentOption) { + case "compilerOptions": + currentOption = options; + break; + case "watchOptions": + currentOption = (watchOptions || (watchOptions = {})); + break; + case "typeAcquisition": + currentOption = (typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName))); + break; + case "typingOptions": + currentOption = (typingOptionstypeAcquisition || (typingOptionstypeAcquisition = getDefaultTypeAcquisition(configFileName))); + break; + default: + ts.Debug.fail("Unknown option"); + } + currentOption[option.name] = normalizeOptionValue(option, basePath, value); + }, + onSetValidOptionKeyValueInRoot: function (key, _keyNode, value, valueNode) { + switch (key) { + case "extends": + var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath; + extendedConfigPath = getExtendsConfigPath(value, host, newBase, errors, function (message, arg0) { + return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0); + }); + return; + } + }, + onSetUnknownOptionKeyValueInRoot: function (key, keyNode, _value, _valueNode) { + if (key === "excludes") { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, keyNode, ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude)); + } + } + }; + var json = convertToObjectWorker(sourceFile, errors, true, getTsconfigRootOptionsMap(), optionsIterator); + if (!typeAcquisition) { + if (typingOptionstypeAcquisition) { + typeAcquisition = (typingOptionstypeAcquisition.enableAutoDiscovery !== undefined) ? + { + enable: typingOptionstypeAcquisition.enableAutoDiscovery, + include: typingOptionstypeAcquisition.include, + exclude: typingOptionstypeAcquisition.exclude + } : + typingOptionstypeAcquisition; + } + else { + typeAcquisition = getDefaultTypeAcquisition(configFileName); + } + } + return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath }; + } + function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) { + extendedConfig = ts.normalizeSlashes(extendedConfig); + if (ts.isRootedDiskPath(extendedConfig) || ts.startsWith(extendedConfig, "./") || ts.startsWith(extendedConfig, "../")) { + var extendedConfigPath = ts.getNormalizedAbsolutePath(extendedConfig, basePath); + if (!host.fileExists(extendedConfigPath) && !ts.endsWith(extendedConfigPath, ".json")) { + extendedConfigPath = extendedConfigPath + ".json"; + if (!host.fileExists(extendedConfigPath)) { + errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)); + return undefined; + } + } + return extendedConfigPath; + } + var resolved = ts.nodeModuleNameResolver(extendedConfig, ts.combinePaths(basePath, "tsconfig.json"), { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, undefined, undefined, true); + if (resolved.resolvedModule) { + return resolved.resolvedModule.resolvedFileName; + } + errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)); + return undefined; + } + function getExtendedConfig(sourceFile, extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache) { + var _a; + var path = host.useCaseSensitiveFileNames ? extendedConfigPath : ts.toFileNameLowerCase(extendedConfigPath); + var value; + var extendedResult; + var extendedConfig; + if (extendedConfigCache && (value = extendedConfigCache.get(path))) { + (extendedResult = value.extendedResult, extendedConfig = value.extendedConfig); + } + else { + extendedResult = readJsonConfigFile(extendedConfigPath, function (path) { return host.readFile(path); }); + if (!extendedResult.parseDiagnostics.length) { + var extendedDirname = ts.getDirectoryPath(extendedConfigPath); + extendedConfig = parseConfig(undefined, extendedResult, host, extendedDirname, ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache); + if (isSuccessfulParsedTsconfig(extendedConfig)) { + var relativeDifference_1 = ts.convertToRelativePath(extendedDirname, basePath, ts.identity); + var updatePath_1 = function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1, path); }; + var mapPropertiesInRawIfNotUndefined = function (propertyName) { + if (raw_2[propertyName]) { + raw_2[propertyName] = ts.map(raw_2[propertyName], updatePath_1); + } + }; + var raw_2 = extendedConfig.raw; + mapPropertiesInRawIfNotUndefined("include"); + mapPropertiesInRawIfNotUndefined("exclude"); + mapPropertiesInRawIfNotUndefined("files"); + } + } + if (extendedConfigCache) { + extendedConfigCache.set(path, { extendedResult: extendedResult, extendedConfig: extendedConfig }); + } + } + if (sourceFile) { + sourceFile.extendedSourceFiles = [extendedResult.fileName]; + if (extendedResult.extendedSourceFiles) { + (_a = sourceFile.extendedSourceFiles).push.apply(_a, extendedResult.extendedSourceFiles); + } + } + if (extendedResult.parseDiagnostics.length) { + errors.push.apply(errors, extendedResult.parseDiagnostics); + return undefined; + } + return extendedConfig; + } + function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) { + if (!ts.hasProperty(jsonOption, ts.compileOnSaveCommandLineOption.name)) { + return false; + } + var result = convertJsonOption(ts.compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors); + return typeof result === "boolean" && result; + } + function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) { + var errors = []; + var options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName); + return { options: options, errors: errors }; + } + ts.convertCompilerOptionsFromJson = convertCompilerOptionsFromJson; + function convertTypeAcquisitionFromJson(jsonOptions, basePath, configFileName) { + var errors = []; + var options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName); + return { options: options, errors: errors }; + } + ts.convertTypeAcquisitionFromJson = convertTypeAcquisitionFromJson; + function getDefaultCompilerOptions(configFileName) { + var options = configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json" + ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true } + : {}; + return options; + } + function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) { + var options = getDefaultCompilerOptions(configFileName); + convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, ts.compilerOptionsDidYouMeanDiagnostics, errors); + if (configFileName) { + options.configFilePath = ts.normalizeSlashes(configFileName); + } + return options; + } + function getDefaultTypeAcquisition(configFileName) { + return { enable: !!configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] }; + } + function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) { + var options = getDefaultTypeAcquisition(configFileName); + var typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions); + convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors); + return options; + } + function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) { + return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, undefined, watchOptionsDidYouMeanDiagnostics, errors); + } + function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) { + if (!jsonOptions) { + return; + } + for (var id in jsonOptions) { + var opt = optionsNameMap.get(id); + if (opt) { + (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors); + } + else { + errors.push(createUnknownOptionError(id, diagnostics, ts.createCompilerDiagnostic)); + } + } + return defaultOptions; + } + function convertJsonOption(opt, value, basePath, errors) { + if (isCompilerOptionsValue(opt, value)) { + var optType = opt.type; + if (optType === "list" && ts.isArray(value)) { + return convertJsonOptionOfListType(opt, value, basePath, errors); + } + else if (!ts.isString(optType)) { + return convertJsonOptionOfCustomType(opt, value, errors); + } + return normalizeNonListOptionValue(opt, basePath, value); + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt))); + } + } + function normalizeOptionValue(option, basePath, value) { + if (isNullOrUndefined(value)) + return undefined; + if (option.type === "list") { + var listOption_1 = option; + if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) { + return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return !!v; }); + } + return value; + } + else if (!ts.isString(option.type)) { + return option.type.get(ts.isString(value) ? value.toLowerCase() : value); + } + return normalizeNonListOptionValue(option, basePath, value); + } + function normalizeNonListOptionValue(option, basePath, value) { + if (option.isFilePath) { + value = ts.getNormalizedAbsolutePath(value, basePath); + if (value === "") { + value = "."; + } + } + return value; + } + function convertJsonOptionOfCustomType(opt, value, errors) { + if (isNullOrUndefined(value)) + return undefined; + var key = value.toLowerCase(); + var val = opt.type.get(key); + if (val !== undefined) { + return val; + } + else { + errors.push(createCompilerDiagnosticForInvalidCustomType(opt)); + } + } + function convertJsonOptionOfListType(option, values, basePath, errors) { + return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; }); + } + function trimString(s) { + return typeof s.trim === "function" ? s.trim() : s.replace(/^[\s]+|[\s]+$/g, ""); + } + var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/; + var invalidDotDotAfterRecursiveWildcardPattern = /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/; + var watchRecursivePattern = /\/[^/]*?[*?][^/]*\//; + var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/; + function matchFileNames(filesSpecs, includeSpecs, excludeSpecs, basePath, options, host, errors, extraFileExtensions, jsonSourceFile) { + basePath = ts.normalizePath(basePath); + var validatedIncludeSpecs, validatedExcludeSpecs; + if (includeSpecs) { + validatedIncludeSpecs = validateSpecs(includeSpecs, errors, false, jsonSourceFile, "include"); + } + if (excludeSpecs) { + validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, true, jsonSourceFile, "exclude"); + } + var wildcardDirectories = getWildcardDirectories(validatedIncludeSpecs, validatedExcludeSpecs, basePath, host.useCaseSensitiveFileNames); + var spec = { filesSpecs: filesSpecs, includeSpecs: includeSpecs, excludeSpecs: excludeSpecs, validatedIncludeSpecs: validatedIncludeSpecs, validatedExcludeSpecs: validatedExcludeSpecs, wildcardDirectories: wildcardDirectories }; + return getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions); + } + function getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions) { + if (extraFileExtensions === void 0) { extraFileExtensions = []; } + basePath = ts.normalizePath(basePath); + var keyMapper = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + var literalFileMap = ts.createMap(); + var wildcardFileMap = ts.createMap(); + var wildCardJsonFileMap = ts.createMap(); + var filesSpecs = spec.filesSpecs, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs, wildcardDirectories = spec.wildcardDirectories; + var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions); + var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions); + if (filesSpecs) { + for (var _i = 0, filesSpecs_1 = filesSpecs; _i < filesSpecs_1.length; _i++) { + var fileName = filesSpecs_1[_i]; + var file = ts.getNormalizedAbsolutePath(fileName, basePath); + literalFileMap.set(keyMapper(file), file); + } + } + var jsonOnlyIncludeRegexes; + if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) { + var _loop_5 = function (file) { + if (ts.fileExtensionIs(file, ".json")) { + if (!jsonOnlyIncludeRegexes) { + var includes = validatedIncludeSpecs.filter(function (s) { return ts.endsWith(s, ".json"); }); + var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^" + pattern + "$"; }); + jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(function (pattern) { return ts.getRegexFromPattern(pattern, host.useCaseSensitiveFileNames); }) : ts.emptyArray; + } + var includeIndex = ts.findIndex(jsonOnlyIncludeRegexes, function (re) { return re.test(file); }); + if (includeIndex !== -1) { + var key_1 = keyMapper(file); + if (!literalFileMap.has(key_1) && !wildCardJsonFileMap.has(key_1)) { + wildCardJsonFileMap.set(key_1, file); + } + } + return "continue"; + } + if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) { + return "continue"; + } + removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper); + var key = keyMapper(file); + if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) { + wildcardFileMap.set(key, file); + } + }; + for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensionsWithJsonIfResolveJsonModule, validatedExcludeSpecs, validatedIncludeSpecs, undefined); _a < _b.length; _a++) { + var file = _b[_a]; + _loop_5(file); + } + } + var literalFiles = ts.arrayFrom(literalFileMap.values()); + var wildcardFiles = ts.arrayFrom(wildcardFileMap.values()); + return { + fileNames: literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())), + wildcardDirectories: wildcardDirectories, + spec: spec + }; + } + ts.getFileNamesFromConfigSpecs = getFileNamesFromConfigSpecs; + function validateSpecs(specs, errors, allowTrailingRecursion, jsonSourceFile, specKey) { + return specs.filter(function (spec) { + var diag = specToDiagnostic(spec, allowTrailingRecursion); + if (diag !== undefined) { + errors.push(createDiagnostic(diag, spec)); + } + return diag === undefined; + }); + function createDiagnostic(message, spec) { + var element = ts.getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec); + return element ? + ts.createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : + ts.createCompilerDiagnostic(message, spec); + } + } + function specToDiagnostic(spec, allowTrailingRecursion) { + if (!allowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) { + return ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0; + } + else if (invalidDotDotAfterRecursiveWildcardPattern.test(spec)) { + return ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0; + } + } + function getWildcardDirectories(include, exclude, path, useCaseSensitiveFileNames) { + var rawExcludeRegex = ts.getRegularExpressionForWildcard(exclude, path, "exclude"); + var excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i"); + var wildcardDirectories = {}; + if (include !== undefined) { + var recursiveKeys = []; + for (var _i = 0, include_1 = include; _i < include_1.length; _i++) { + var file = include_1[_i]; + var spec = ts.normalizePath(ts.combinePaths(path, file)); + if (excludeRegex && excludeRegex.test(spec)) { + continue; + } + var match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames); + if (match) { + var key = match.key, flags = match.flags; + var existingFlags = wildcardDirectories[key]; + if (existingFlags === undefined || existingFlags < flags) { + wildcardDirectories[key] = flags; + if (flags === 1) { + recursiveKeys.push(key); + } + } + } + } + for (var key in wildcardDirectories) { + if (ts.hasProperty(wildcardDirectories, key)) { + for (var _a = 0, recursiveKeys_1 = recursiveKeys; _a < recursiveKeys_1.length; _a++) { + var recursiveKey = recursiveKeys_1[_a]; + if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) { + delete wildcardDirectories[key]; + } + } + } + } + } + return wildcardDirectories; + } + function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) { + var match = wildcardDirectoryPattern.exec(spec); + if (match) { + return { + key: useCaseSensitiveFileNames ? match[0] : ts.toFileNameLowerCase(match[0]), + flags: watchRecursivePattern.test(spec) ? 1 : 0 + }; + } + if (ts.isImplicitGlob(spec)) { + return { key: spec, flags: 1 }; + } + return undefined; + } + function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) { + var extensionPriority = ts.getExtensionPriority(file, extensions); + var adjustedExtensionPriority = ts.adjustExtensionPriority(extensionPriority, extensions); + for (var i = 0; i < adjustedExtensionPriority; i++) { + var higherPriorityExtension = extensions[i]; + var higherPriorityPath = keyMapper(ts.changeExtension(file, higherPriorityExtension)); + if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) { + return true; + } + } + return false; + } + function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) { + var extensionPriority = ts.getExtensionPriority(file, extensions); + var nextExtensionPriority = ts.getNextLowestExtensionPriority(extensionPriority, extensions); + for (var i = nextExtensionPriority; i < extensions.length; i++) { + var lowerPriorityExtension = extensions[i]; + var lowerPriorityPath = keyMapper(ts.changeExtension(file, lowerPriorityExtension)); + wildcardFiles.delete(lowerPriorityPath); + } + } + function convertCompilerOptionsForTelemetry(opts) { + var out = {}; + for (var key in opts) { + if (opts.hasOwnProperty(key)) { + var type = getOptionFromName(key); + if (type !== undefined) { + out[key] = getOptionValueWithEmptyStrings(opts[key], type); + } + } + } + return out; + } + ts.convertCompilerOptionsForTelemetry = convertCompilerOptionsForTelemetry; + function getOptionValueWithEmptyStrings(value, option) { + switch (option.type) { + case "object": + return ""; + case "string": + return ""; + case "number": + return typeof value === "number" ? value : ""; + case "boolean": + return typeof value === "boolean" ? value : ""; + case "list": + var elementType_1 = option.element; + return ts.isArray(value) ? value.map(function (v) { return getOptionValueWithEmptyStrings(v, elementType_1); }) : ""; + default: + return ts.forEachEntry(option.type, function (optionEnumValue, optionStringValue) { + if (optionEnumValue === value) { + return optionStringValue; + } + }); + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function trace(host) { + host.trace(ts.formatMessage.apply(undefined, arguments)); + } + ts.trace = trace; + function isTraceEnabled(compilerOptions, host) { + return !!compilerOptions.traceResolution && host.trace !== undefined; + } + ts.isTraceEnabled = isTraceEnabled; + function withPackageId(packageInfo, r) { + var packageId; + if (r && packageInfo) { + var packageJsonContent = packageInfo.packageJsonContent; + if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") { + packageId = { + name: packageJsonContent.name, + subModuleName: r.path.slice(packageInfo.packageDirectory.length + ts.directorySeparator.length), + version: packageJsonContent.version + }; + } + } + return r && { path: r.path, extension: r.ext, packageId: packageId }; + } + function noPackageId(r) { + return withPackageId(undefined, r); + } + function removeIgnoredPackageId(r) { + if (r) { + ts.Debug.assert(r.packageId === undefined); + return { path: r.path, ext: r.extension }; + } + } + var Extensions; + (function (Extensions) { + Extensions[Extensions["TypeScript"] = 0] = "TypeScript"; + Extensions[Extensions["JavaScript"] = 1] = "JavaScript"; + Extensions[Extensions["Json"] = 2] = "Json"; + Extensions[Extensions["TSConfig"] = 3] = "TSConfig"; + Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; + })(Extensions || (Extensions = {})); + function resolvedTypeScriptOnly(resolved) { + if (!resolved) { + return undefined; + } + ts.Debug.assert(ts.extensionIsTS(resolved.extension)); + return { fileName: resolved.path, packageId: resolved.packageId }; + } + function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations) { + return { + resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId }, + failedLookupLocations: failedLookupLocations + }; + } + function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) { + if (!ts.hasProperty(jsonContent, fieldName)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_does_not_have_a_0_field, fieldName); + } + return; + } + var value = jsonContent[fieldName]; + if (typeof value !== typeOfTag || value === null) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value); + } + return; + } + return value; + } + function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) { + var fileName = readPackageJsonField(jsonContent, fieldName, "string", state); + if (fileName === undefined) { + return; + } + if (!fileName) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_had_a_falsy_0_field, fieldName); + } + return; + } + var path = ts.normalizePath(ts.combinePaths(baseDirectory, fileName)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path); + } + return path; + } + function readPackageJsonTypesFields(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) + || readPackageJsonPathField(jsonContent, "types", baseDirectory, state); + } + function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state); + } + function readPackageJsonMainField(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "main", baseDirectory, state); + } + function readPackageJsonTypesVersionsField(jsonContent, state) { + var typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state); + if (typesVersions === undefined) + return; + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings); + } + return typesVersions; + } + function readPackageJsonTypesVersionPaths(jsonContent, state) { + var typesVersions = readPackageJsonTypesVersionsField(jsonContent, state); + if (typesVersions === undefined) + return; + if (state.traceEnabled) { + for (var key in typesVersions) { + if (ts.hasProperty(typesVersions, key) && !ts.VersionRange.tryParse(key)) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key); + } + } + } + var result = getPackageJsonTypesVersionsPaths(typesVersions); + if (!result) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, ts.versionMajorMinor); + } + return; + } + var bestVersionKey = result.version, bestVersionPaths = result.paths; + if (typeof bestVersionPaths !== "object") { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['" + bestVersionKey + "']", "object", typeof bestVersionPaths); + } + return; + } + return result; + } + var typeScriptVersion; + function getPackageJsonTypesVersionsPaths(typesVersions) { + if (!typeScriptVersion) + typeScriptVersion = new ts.Version(ts.version); + for (var key in typesVersions) { + if (!ts.hasProperty(typesVersions, key)) + continue; + var keyRange = ts.VersionRange.tryParse(key); + if (keyRange === undefined) { + continue; + } + if (keyRange.test(typeScriptVersion)) { + return { version: key, paths: typesVersions[key] }; + } + } + } + ts.getPackageJsonTypesVersionsPaths = getPackageJsonTypesVersionsPaths; + function getEffectiveTypeRoots(options, host) { + if (options.typeRoots) { + return options.typeRoots; + } + var currentDirectory; + if (options.configFilePath) { + currentDirectory = ts.getDirectoryPath(options.configFilePath); + } + else if (host.getCurrentDirectory) { + currentDirectory = host.getCurrentDirectory(); + } + if (currentDirectory !== undefined) { + return getDefaultTypeRoots(currentDirectory, host); + } + } + ts.getEffectiveTypeRoots = getEffectiveTypeRoots; + function getDefaultTypeRoots(currentDirectory, host) { + if (!host.directoryExists) { + return [ts.combinePaths(currentDirectory, nodeModulesAtTypes)]; + } + var typeRoots; + ts.forEachAncestorDirectory(ts.normalizePath(currentDirectory), function (directory) { + var atTypes = ts.combinePaths(directory, nodeModulesAtTypes); + if (host.directoryExists(atTypes)) { + (typeRoots || (typeRoots = [])).push(atTypes); + } + return undefined; + }); + return typeRoots; + } + var nodeModulesAtTypes = ts.combinePaths("node_modules", "@types"); + function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference) { + var traceEnabled = isTraceEnabled(options, host); + if (redirectedReference) { + options = redirectedReference.commandLine.options; + } + var failedLookupLocations = []; + var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations }; + var typeRoots = getEffectiveTypeRoots(options, host); + if (traceEnabled) { + if (containingFile === undefined) { + if (typeRoots === undefined) { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName); + } + else { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots); + } + } + else { + if (typeRoots === undefined) { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile); + } + else { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots); + } + } + if (redirectedReference) { + trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName); + } + } + var resolved = primaryLookup(); + var primary = true; + if (!resolved) { + resolved = secondaryLookup(); + primary = false; + } + var resolvedTypeReferenceDirective; + if (resolved) { + var fileName = resolved.fileName, packageId = resolved.packageId; + var resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled); + if (traceEnabled) { + if (packageId) { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, resolvedFileName, ts.packageIdToString(packageId), primary); + } + else { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFileName, primary); + } + } + resolvedTypeReferenceDirective = { primary: primary, resolvedFileName: resolvedFileName, packageId: packageId, isExternalLibraryImport: pathContainsNodeModules(fileName) }; + } + return { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations }; + function primaryLookup() { + if (typeRoots && typeRoots.length) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", ")); + } + return ts.firstDefined(typeRoots, function (typeRoot) { + var candidate = ts.combinePaths(typeRoot, typeReferenceDirectiveName); + var candidateDirectory = ts.getDirectoryPath(candidate); + var directoryExists = ts.directoryProbablyExists(candidateDirectory, host); + if (!directoryExists && traceEnabled) { + trace(host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory); + } + return resolvedTypeScriptOnly(loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, !directoryExists, moduleResolutionState)); + }); + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths); + } + } + } + function secondaryLookup() { + var initialLocationForSecondaryLookup = containingFile && ts.getDirectoryPath(containingFile); + if (initialLocationForSecondaryLookup !== undefined) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup); + } + var result = void 0; + if (!ts.isExternalModuleNameRelative(typeReferenceDirectiveName)) { + var searchResult = loadModuleFromNearestNodeModulesDirectory(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, undefined, undefined); + result = searchResult && searchResult.value; + } + else { + var candidate = ts.normalizePathAndParts(ts.combinePaths(initialLocationForSecondaryLookup, typeReferenceDirectiveName)).path; + result = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, false, moduleResolutionState, true); + } + var resolvedFile = resolvedTypeScriptOnly(result); + if (!resolvedFile && traceEnabled) { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName); + } + return resolvedFile; + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder); + } + } + } + } + ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective; + function getAutomaticTypeDirectiveNames(options, host) { + if (options.types) { + return options.types; + } + var result = []; + if (host.directoryExists && host.getDirectories) { + var typeRoots = getEffectiveTypeRoots(options, host); + if (typeRoots) { + for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) { + var root = typeRoots_1[_i]; + if (host.directoryExists(root)) { + for (var _a = 0, _b = host.getDirectories(root); _a < _b.length; _a++) { + var typeDirectivePath = _b[_a]; + var normalized = ts.normalizePath(typeDirectivePath); + var packageJsonPath = ts.combinePaths(root, normalized, "package.json"); + var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null; + if (!isNotNeededPackage) { + var baseFileName = ts.getBaseFileName(normalized); + if (baseFileName.charCodeAt(0) !== 46) { + result.push(baseFileName); + } + } + } + } + } + } + } + return result; + } + ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames; + function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) { + return createModuleResolutionCacheWithMaps(createCacheWithRedirects(options), createCacheWithRedirects(options), currentDirectory, getCanonicalFileName); + } + ts.createModuleResolutionCache = createModuleResolutionCache; + function createCacheWithRedirects(options) { + var ownMap = ts.createMap(); + var redirectsMap = ts.createMap(); + return { + ownMap: ownMap, + redirectsMap: redirectsMap, + getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects, + clear: clear, + setOwnOptions: setOwnOptions, + setOwnMap: setOwnMap + }; + function setOwnOptions(newOptions) { + options = newOptions; + } + function setOwnMap(newOwnMap) { + ownMap = newOwnMap; + } + function getOrCreateMapOfCacheRedirects(redirectedReference) { + if (!redirectedReference) { + return ownMap; + } + var path = redirectedReference.sourceFile.path; + var redirects = redirectsMap.get(path); + if (!redirects) { + redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? ts.createMap() : ownMap; + redirectsMap.set(path, redirects); + } + return redirects; + } + function clear() { + ownMap.clear(); + redirectsMap.clear(); + } + } + ts.createCacheWithRedirects = createCacheWithRedirects; + function createModuleResolutionCacheWithMaps(directoryToModuleNameMap, moduleNameToDirectoryMap, currentDirectory, getCanonicalFileName) { + return { getOrCreateCacheForDirectory: getOrCreateCacheForDirectory, getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, directoryToModuleNameMap: directoryToModuleNameMap, moduleNameToDirectoryMap: moduleNameToDirectoryMap }; + function getOrCreateCacheForDirectory(directoryName, redirectedReference) { + var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName); + return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, ts.createMap); + } + function getOrCreateCacheForModuleName(nonRelativeModuleName, redirectedReference) { + ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName)); + return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, nonRelativeModuleName, createPerModuleNameCache); + } + function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) { + var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference); + var result = cache.get(key); + if (!result) { + result = create(); + cache.set(key, result); + } + return result; + } + function createPerModuleNameCache() { + var directoryPathMap = ts.createMap(); + return { get: get, set: set }; + function get(directory) { + return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName)); + } + function set(directory, result) { + var path = ts.toPath(directory, currentDirectory, getCanonicalFileName); + if (directoryPathMap.has(path)) { + return; + } + directoryPathMap.set(path, result); + var resolvedFileName = result.resolvedModule && + (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName); + var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName); + var current = path; + while (current !== commonPrefix) { + var parent = ts.getDirectoryPath(current); + if (parent === current || directoryPathMap.has(parent)) { + break; + } + directoryPathMap.set(parent, result); + current = parent; + } + } + function getCommonPrefix(directory, resolution) { + var resolutionDirectory = ts.toPath(ts.getDirectoryPath(resolution), currentDirectory, getCanonicalFileName); + var i = 0; + var limit = Math.min(directory.length, resolutionDirectory.length); + while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) { + i++; + } + if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === ts.directorySeparator)) { + return directory; + } + var rootLength = ts.getRootLength(directory); + if (i < rootLength) { + return undefined; + } + var sep = directory.lastIndexOf(ts.directorySeparator, i - 1); + if (sep === -1) { + return undefined; + } + return directory.substr(0, Math.max(sep, rootLength)); + } + } + } + ts.createModuleResolutionCacheWithMaps = createModuleResolutionCacheWithMaps; + function resolveModuleNameFromCache(moduleName, containingFile, cache) { + var containingDirectory = ts.getDirectoryPath(containingFile); + var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory); + return perFolderCache && perFolderCache.get(moduleName); + } + ts.resolveModuleNameFromCache = resolveModuleNameFromCache; + function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + if (redirectedReference) { + compilerOptions = redirectedReference.commandLine.options; + } + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile); + if (redirectedReference) { + trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName); + } + } + var containingDirectory = ts.getDirectoryPath(containingFile); + var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference); + var result = perFolderCache && perFolderCache.get(moduleName); + if (result) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory); + } + } + else { + var moduleResolution = compilerOptions.moduleResolution; + if (moduleResolution === undefined) { + moduleResolution = ts.getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic; + if (traceEnabled) { + trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]); + } + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts.ModuleResolutionKind[moduleResolution]); + } + } + ts.perfLogger.logStartResolveModule(moduleName); + switch (moduleResolution) { + case ts.ModuleResolutionKind.NodeJs: + result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + break; + case ts.ModuleResolutionKind.Classic: + result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + break; + default: + return ts.Debug.fail("Unexpected moduleResolution: " + moduleResolution); + } + if (result && result.resolvedModule) + ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\""); + ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null"); + if (perFolderCache) { + perFolderCache.set(moduleName, result); + if (!ts.isExternalModuleNameRelative(moduleName)) { + cache.getOrCreateCacheForModuleName(moduleName, redirectedReference).set(containingDirectory, result); + } + } + } + if (traceEnabled) { + if (result.resolvedModule) { + if (result.resolvedModule.packageId) { + trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, ts.packageIdToString(result.resolvedModule.packageId)); + } + else { + trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName); + } + } + else { + trace(host, ts.Diagnostics.Module_name_0_was_not_resolved, moduleName); + } + } + return result; + } + ts.resolveModuleName = resolveModuleName; + function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) { + var resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state); + if (resolved) + return resolved.value; + if (!ts.isExternalModuleNameRelative(moduleName)) { + return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state); + } + else { + return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state); + } + } + function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) { + var _a = state.compilerOptions, baseUrl = _a.baseUrl, paths = _a.paths; + if (baseUrl && paths && !ts.pathIsRelative(moduleName)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName); + trace(state.host, ts.Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName); + } + return tryLoadModuleUsingPaths(extensions, moduleName, baseUrl, paths, loader, false, state); + } + } + function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) { + if (!state.compilerOptions.rootDirs) { + return undefined; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName); + } + var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName)); + var matchedRootDir; + var matchedNormalizedPrefix; + for (var _i = 0, _a = state.compilerOptions.rootDirs; _i < _a.length; _i++) { + var rootDir = _a[_i]; + var normalizedRoot = ts.normalizePath(rootDir); + if (!ts.endsWith(normalizedRoot, ts.directorySeparator)) { + normalizedRoot += ts.directorySeparator; + } + var isLongestMatchingPrefix = ts.startsWith(candidate, normalizedRoot) && + (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix); + } + if (isLongestMatchingPrefix) { + matchedNormalizedPrefix = normalizedRoot; + matchedRootDir = rootDir; + } + } + if (matchedNormalizedPrefix) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix); + } + var suffix = candidate.substr(matchedNormalizedPrefix.length); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate); + } + var resolvedFileName = loader(extensions, candidate, !ts.directoryProbablyExists(containingDirectory, state.host), state); + if (resolvedFileName) { + return resolvedFileName; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Trying_other_entries_in_rootDirs); + } + for (var _b = 0, _c = state.compilerOptions.rootDirs; _b < _c.length; _b++) { + var rootDir = _c[_b]; + if (rootDir === matchedRootDir) { + continue; + } + var candidate_1 = ts.combinePaths(ts.normalizePath(rootDir), suffix); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate_1); + } + var baseDirectory = ts.getDirectoryPath(candidate_1); + var resolvedFileName_1 = loader(extensions, candidate_1, !ts.directoryProbablyExists(baseDirectory, state.host), state); + if (resolvedFileName_1) { + return resolvedFileName_1; + } + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Module_resolution_using_rootDirs_has_failed); + } + } + return undefined; + } + function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) { + var baseUrl = state.compilerOptions.baseUrl; + if (!baseUrl) { + return undefined; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName); + } + var candidate = ts.normalizePath(ts.combinePaths(baseUrl, moduleName)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate); + } + return loader(extensions, candidate, !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state); + } + function resolveJSModule(moduleName, initialDir, host) { + var _a = tryResolveJSModuleWorker(moduleName, initialDir, host), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations; + if (!resolvedModule) { + throw new Error("Could not resolve JS module '" + moduleName + "' starting at '" + initialDir + "'. Looked in: " + failedLookupLocations.join(", ")); + } + return resolvedModule.resolvedFileName; + } + ts.resolveJSModule = resolveJSModule; + function tryResolveJSModule(moduleName, initialDir, host) { + var resolvedModule = tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule; + return resolvedModule && resolvedModule.resolvedFileName; + } + ts.tryResolveJSModule = tryResolveJSModule; + var jsOnlyExtensions = [Extensions.JavaScript]; + var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript]; + var tsPlusJsonExtensions = __spreadArrays(tsExtensions, [Extensions.Json]); + var tsconfigExtensions = [Extensions.TSConfig]; + function tryResolveJSModuleWorker(moduleName, initialDir, host) { + return nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, undefined, jsOnlyExtensions, undefined); + } + function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) { + return nodeModuleNameResolverWorker(moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference); + } + ts.nodeModuleNameResolver = nodeModuleNameResolver; + function nodeModuleNameResolverWorker(moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + var failedLookupLocations = []; + var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations }; + var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); }); + if (result && result.value) { + var _a = result.value, resolved = _a.resolved, isExternalLibraryImport = _a.isExternalLibraryImport; + return createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations); + } + return { resolvedModule: undefined, failedLookupLocations: failedLookupLocations }; + function tryResolve(extensions) { + var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, true); }; + var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state); + if (resolved) { + return toSearchResult({ resolved: resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) }); + } + if (!ts.isExternalModuleNameRelative(moduleName)) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]); + } + var resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference); + if (!resolved_1) + return undefined; + var resolvedValue = resolved_1.value; + if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) { + var path = realPath(resolvedValue.path, host, traceEnabled); + var originalPath = path === resolvedValue.path ? undefined : resolvedValue.path; + resolvedValue = __assign(__assign({}, resolvedValue), { path: path, originalPath: originalPath }); + } + return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } }; + } + else { + var _a = ts.normalizePathAndParts(ts.combinePaths(containingDirectory, moduleName)), candidate = _a.path, parts = _a.parts; + var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, false, state, true); + return resolved_2 && toSearchResult({ resolved: resolved_2, isExternalLibraryImport: ts.contains(parts, "node_modules") }); + } + } + } + function realPath(path, host, traceEnabled) { + if (!host.realpath) { + return path; + } + var real = ts.normalizePath(host.realpath(path)); + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, path, real); + } + ts.Debug.assert(host.fileExists(real), path + " linked to nonexistent file " + real); + return real; + } + function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]); + } + if (!ts.hasTrailingDirectorySeparator(candidate)) { + if (!onlyRecordFailures) { + var parentOfCandidate = ts.getDirectoryPath(candidate); + if (!ts.directoryProbablyExists(parentOfCandidate, state.host)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate); + } + onlyRecordFailures = true; + } + } + var resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state); + if (resolvedFromFile) { + var packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile) : undefined; + var packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, false, state) : undefined; + return withPackageId(packageInfo, resolvedFromFile); + } + } + if (!onlyRecordFailures) { + var candidateExists = ts.directoryProbablyExists(candidate, state.host); + if (!candidateExists) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate); + } + onlyRecordFailures = true; + } + } + return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson); + } + ts.nodeModulesPathPart = "/node_modules/"; + function pathContainsNodeModules(path) { + return ts.stringContains(path, ts.nodeModulesPathPart); + } + ts.pathContainsNodeModules = pathContainsNodeModules; + function parseNodeModuleFromPath(resolved) { + var path = ts.normalizePath(resolved.path); + var idx = path.lastIndexOf(ts.nodeModulesPathPart); + if (idx === -1) { + return undefined; + } + var indexAfterNodeModules = idx + ts.nodeModulesPathPart.length; + var indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules); + if (path.charCodeAt(indexAfterNodeModules) === 64) { + indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName); + } + return path.slice(0, indexAfterPackageName); + } + function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) { + var nextSeparatorIndex = path.indexOf(ts.directorySeparator, prevSeparatorIndex + 1); + return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex; + } + function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) { + return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state)); + } + function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) { + if (extensions === Extensions.Json || extensions === Extensions.TSConfig) { + var extensionLess = ts.tryRemoveExtension(candidate, ".json"); + return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, onlyRecordFailures, state); + } + var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, onlyRecordFailures, state); + if (resolvedByAddingExtension) { + return resolvedByAddingExtension; + } + if (ts.hasJSFileExtension(candidate)) { + var extensionless = ts.removeFileExtension(candidate); + if (state.traceEnabled) { + var extension = candidate.substring(extensionless.length); + trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension); + } + return tryAddingExtensions(extensionless, extensions, onlyRecordFailures, state); + } + } + function tryAddingExtensions(candidate, extensions, onlyRecordFailures, state) { + if (!onlyRecordFailures) { + var directory = ts.getDirectoryPath(candidate); + if (directory) { + onlyRecordFailures = !ts.directoryProbablyExists(directory, state.host); + } + } + switch (extensions) { + case Extensions.DtsOnly: + return tryExtension(".d.ts"); + case Extensions.TypeScript: + return tryExtension(".ts") || tryExtension(".tsx") || tryExtension(".d.ts"); + case Extensions.JavaScript: + return tryExtension(".js") || tryExtension(".jsx"); + case Extensions.TSConfig: + case Extensions.Json: + return tryExtension(".json"); + } + function tryExtension(ext) { + var path = tryFile(candidate + ext, onlyRecordFailures, state); + return path === undefined ? undefined : { path: path, ext: ext }; + } + } + function tryFile(fileName, onlyRecordFailures, state) { + if (!onlyRecordFailures) { + if (state.host.fileExists(fileName)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName); + } + return fileName; + } + else { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName); + } + } + } + state.failedLookupLocations.push(fileName); + return undefined; + } + function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson) { + if (considerPackageJson === void 0) { considerPackageJson = true; } + var packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : undefined; + var packageJsonContent = packageInfo && packageInfo.packageJsonContent; + var versionPaths = packageInfo && packageInfo.versionPaths; + return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths)); + } + function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) { + var host = state.host, traceEnabled = state.traceEnabled; + var directoryExists = !onlyRecordFailures && ts.directoryProbablyExists(packageDirectory, host); + var packageJsonPath = ts.combinePaths(packageDirectory, "package.json"); + if (directoryExists && host.fileExists(packageJsonPath)) { + var packageJsonContent = ts.readJson(packageJsonPath, host); + if (traceEnabled) { + trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath); + } + var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state); + return { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths }; + } + else { + if (directoryExists && traceEnabled) { + trace(host, ts.Diagnostics.File_0_does_not_exist, packageJsonPath); + } + state.failedLookupLocations.push(packageJsonPath); + } + } + function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) { + var packageFile; + if (jsonContent) { + switch (extensions) { + case Extensions.JavaScript: + case Extensions.Json: + packageFile = readPackageJsonMainField(jsonContent, candidate, state); + break; + case Extensions.TypeScript: + packageFile = readPackageJsonTypesFields(jsonContent, candidate, state) || readPackageJsonMainField(jsonContent, candidate, state); + break; + case Extensions.DtsOnly: + packageFile = readPackageJsonTypesFields(jsonContent, candidate, state); + break; + case Extensions.TSConfig: + packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state); + break; + default: + return ts.Debug.assertNever(extensions); + } + } + var loader = function (extensions, candidate, onlyRecordFailures, state) { + var fromFile = tryFile(candidate, onlyRecordFailures, state); + if (fromFile) { + var resolved = resolvedIfExtensionMatches(extensions, fromFile); + if (resolved) { + return noPackageId(resolved); + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile); + } + } + var nextExtensions = extensions === Extensions.DtsOnly ? Extensions.TypeScript : extensions; + return nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, false); + }; + var onlyRecordFailuresForPackageFile = packageFile ? !ts.directoryProbablyExists(ts.getDirectoryPath(packageFile), state.host) : undefined; + var onlyRecordFailuresForIndex = onlyRecordFailures || !ts.directoryProbablyExists(candidate, state.host); + var indexPath = ts.combinePaths(candidate, extensions === Extensions.TSConfig ? "tsconfig" : "index"); + if (versionPaths && (!packageFile || ts.containsPath(candidate, packageFile))) { + var moduleName = ts.getRelativePathFromDirectory(candidate, packageFile || indexPath, false); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, ts.version, moduleName); + } + var result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state); + if (result) { + return removeIgnoredPackageId(result.value); + } + } + var packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state)); + if (packageFileResult) + return packageFileResult; + return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state); + } + function resolvedIfExtensionMatches(extensions, path) { + var ext = ts.tryGetExtensionFromPath(path); + return ext !== undefined && extensionIsOk(extensions, ext) ? { path: path, ext: ext } : undefined; + } + function extensionIsOk(extensions, extension) { + switch (extensions) { + case Extensions.JavaScript: + return extension === ".js" || extension === ".jsx"; + case Extensions.TSConfig: + case Extensions.Json: + return extension === ".json"; + case Extensions.TypeScript: + return extension === ".ts" || extension === ".tsx" || extension === ".d.ts"; + case Extensions.DtsOnly: + return extension === ".d.ts"; + } + } + function parsePackageName(moduleName) { + var idx = moduleName.indexOf(ts.directorySeparator); + if (moduleName[0] === "@") { + idx = moduleName.indexOf(ts.directorySeparator, idx + 1); + } + return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) }; + } + ts.parsePackageName = parsePackageName; + function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) { + return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference); + } + function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) { + return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, true, undefined, undefined); + } + function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { + var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference); + return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) { + if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") { + var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state); + if (resolutionFromCache) { + return resolutionFromCache; + } + return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly)); + } + }); + } + function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly) { + var nodeModulesFolder = ts.combinePaths(directory, "node_modules"); + var nodeModulesFolderExists = ts.directoryProbablyExists(nodeModulesFolder, state.host); + if (!nodeModulesFolderExists && state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder); + } + var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state); + if (packageResult) { + return packageResult; + } + if (extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) { + var nodeModulesAtTypes_1 = ts.combinePaths(nodeModulesFolder, "@types"); + var nodeModulesAtTypesExists = nodeModulesFolderExists; + if (nodeModulesFolderExists && !ts.directoryProbablyExists(nodeModulesAtTypes_1, state.host)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes_1); + } + nodeModulesAtTypesExists = false; + } + return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state); + } + } + function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state) { + var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName)); + var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state); + if (packageInfo) { + var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state); + if (fromFile) { + return noPackageId(fromFile); + } + var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.packageJsonContent, packageInfo.versionPaths); + return withPackageId(packageInfo, fromDirectory); + } + var loader = function (extensions, candidate, onlyRecordFailures, state) { + var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) || + loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths); + return withPackageId(packageInfo, pathAndExtension); + }; + var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest; + if (rest !== "") { + var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName); + packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state); + if (packageInfo && packageInfo.versionPaths) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.versionPaths.version, ts.version, rest); + } + var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host); + var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, loader, !packageDirectoryExists, state); + if (fromPaths) { + return fromPaths.value; + } + } + } + return loader(extensions, candidate, !nodeModulesDirectoryExists, state); + } + function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, onlyRecordFailures, state) { + var matchedPattern = ts.matchPatternOrExact(ts.getOwnKeys(paths), moduleName); + if (matchedPattern) { + var matchedStar_1 = ts.isString(matchedPattern) ? undefined : ts.matchedText(matchedPattern, moduleName); + var matchedPatternText = ts.isString(matchedPattern) ? matchedPattern : ts.patternText(matchedPattern); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText); + } + var resolved = ts.forEach(paths[matchedPatternText], function (subst) { + var path = matchedStar_1 ? subst.replace("*", matchedStar_1) : subst; + var candidate = ts.normalizePath(ts.combinePaths(baseDirectory, path)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path); + } + var extension = ts.tryGetExtensionFromPath(candidate); + if (extension !== undefined) { + var path_1 = tryFile(candidate, onlyRecordFailures, state); + if (path_1 !== undefined) { + return noPackageId({ path: path_1, ext: extension }); + } + } + return loader(extensions, candidate, onlyRecordFailures || !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state); + }); + return { value: resolved }; + } + } + var mangledScopedPackageSeparator = "__"; + function mangleScopedPackageNameWithTrace(packageName, state) { + var mangled = mangleScopedPackageName(packageName); + if (state.traceEnabled && mangled !== packageName) { + trace(state.host, ts.Diagnostics.Scoped_package_detected_looking_in_0, mangled); + } + return mangled; + } + function getTypesPackageName(packageName) { + return "@types/" + mangleScopedPackageName(packageName); + } + ts.getTypesPackageName = getTypesPackageName; + function mangleScopedPackageName(packageName) { + if (ts.startsWith(packageName, "@")) { + var replaceSlash = packageName.replace(ts.directorySeparator, mangledScopedPackageSeparator); + if (replaceSlash !== packageName) { + return replaceSlash.slice(1); + } + } + return packageName; + } + ts.mangleScopedPackageName = mangleScopedPackageName; + function getPackageNameFromTypesPackageName(mangledName) { + var withoutAtTypePrefix = ts.removePrefix(mangledName, "@types/"); + if (withoutAtTypePrefix !== mangledName) { + return unmangleScopedPackageName(withoutAtTypePrefix); + } + return mangledName; + } + ts.getPackageNameFromTypesPackageName = getPackageNameFromTypesPackageName; + function unmangleScopedPackageName(typesPackageName) { + return ts.stringContains(typesPackageName, mangledScopedPackageSeparator) ? + "@" + typesPackageName.replace(mangledScopedPackageSeparator, ts.directorySeparator) : + typesPackageName; + } + ts.unmangleScopedPackageName = unmangleScopedPackageName; + function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) { + var _a; + var result = cache && cache.get(containingDirectory); + if (result) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory); + } + (_a = state.failedLookupLocations).push.apply(_a, result.failedLookupLocations); + return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, originalPath: result.resolvedModule.originalPath || true, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId } }; + } + } + function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + var failedLookupLocations = []; + var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations }; + var containingDirectory = ts.getDirectoryPath(containingFile); + var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript); + return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations); + function tryResolve(extensions) { + var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state); + if (resolvedUsingSettings) { + return { value: resolvedUsingSettings }; + } + if (!ts.isExternalModuleNameRelative(moduleName)) { + var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference); + var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) { + var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state); + if (resolutionFromCache) { + return resolutionFromCache; + } + var searchName = ts.normalizePath(ts.combinePaths(directory, moduleName)); + return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, false, state)); + }); + if (resolved_3) { + return resolved_3; + } + if (extensions === Extensions.TypeScript) { + return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state); + } + } + else { + var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName)); + return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, false, state)); + } + } + } + ts.classicNameResolver = classicNameResolver; + function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + if (traceEnabled) { + trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache); + } + var failedLookupLocations = []; + var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations }; + var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false); + return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations); + } + ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache; + function toSearchResult(value) { + return value !== undefined ? { value: value } : undefined; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function getModuleInstanceState(node, visited) { + if (node.body && !node.body.parent) { + setParentPointers(node, node.body); + } + return node.body ? getModuleInstanceStateCached(node.body, visited) : 1; + } + ts.getModuleInstanceState = getModuleInstanceState; + function getModuleInstanceStateCached(node, visited) { + if (visited === void 0) { visited = ts.createMap(); } + var nodeId = "" + ts.getNodeId(node); + if (visited.has(nodeId)) { + return visited.get(nodeId) || 0; + } + visited.set(nodeId, undefined); + var result = getModuleInstanceStateWorker(node, visited); + visited.set(nodeId, result); + return result; + } + function getModuleInstanceStateWorker(node, visited) { + switch (node.kind) { + case 246: + case 247: + return 0; + case 248: + if (ts.isEnumConst(node)) { + return 2; + } + break; + case 254: + case 253: + if (!(ts.hasModifier(node, 1))) { + return 0; + } + break; + case 260: + var exportDeclaration = node; + if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 261) { + var state = 0; + for (var _i = 0, _a = exportDeclaration.exportClause.elements; _i < _a.length; _i++) { + var specifier = _a[_i]; + var specifierState = getModuleInstanceStateForAliasTarget(specifier, visited); + if (specifierState > state) { + state = specifierState; + } + if (state === 1) { + return state; + } + } + return state; + } + break; + case 250: { + var state_1 = 0; + ts.forEachChild(node, function (n) { + var childState = getModuleInstanceStateCached(n, visited); + switch (childState) { + case 0: + return; + case 2: + state_1 = 2; + return; + case 1: + state_1 = 1; + return true; + default: + ts.Debug.assertNever(childState); + } + }); + return state_1; + } + case 249: + return getModuleInstanceState(node, visited); + case 75: + if (node.isInJSDocNamespace) { + return 0; + } + } + return 1; + } + function getModuleInstanceStateForAliasTarget(specifier, visited) { + var name = specifier.propertyName || specifier.name; + var p = specifier.parent; + while (p) { + if (ts.isBlock(p) || ts.isModuleBlock(p) || ts.isSourceFile(p)) { + var statements = p.statements; + var found = void 0; + for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) { + var statement = statements_1[_i]; + if (ts.nodeHasName(statement, name)) { + if (!statement.parent) { + setParentPointers(p, statement); + } + var state = getModuleInstanceStateCached(statement, visited); + if (found === undefined || state > found) { + found = state; + } + if (found === 1) { + return found; + } + } + } + if (found !== undefined) { + return found; + } + } + p = p.parent; + } + return 1; + } + function initFlowNode(node) { + ts.Debug.attachFlowNodeDebugInfo(node); + return node; + } + var binder = createBinder(); + function bindSourceFile(file, options) { + ts.performance.mark("beforeBind"); + ts.perfLogger.logStartBindFile("" + file.fileName); + binder(file, options); + ts.perfLogger.logStopBindFile(); + ts.performance.mark("afterBind"); + ts.performance.measure("Bind", "beforeBind", "afterBind"); + } + ts.bindSourceFile = bindSourceFile; + function createBinder() { + var file; + var options; + var languageVersion; + var parent; + var container; + var thisParentContainer; + var blockScopeContainer; + var lastContainer; + var delayedTypeAliases; + var seenThisKeyword; + var currentFlow; + var currentBreakTarget; + var currentContinueTarget; + var currentReturnTarget; + var currentTrueTarget; + var currentFalseTarget; + var currentExceptionTarget; + var preSwitchCaseFlow; + var activeLabelList; + var hasExplicitReturn; + var emitFlags; + var inStrictMode; + var symbolCount = 0; + var Symbol; + var classifiableNames; + var unreachableFlow = { flags: 1 }; + var reportedUnreachableFlow = { flags: 1 }; + var subtreeTransformFlags = 0; + var skipTransformFlagAggregation; + function createDiagnosticForNode(node, message, arg0, arg1, arg2) { + return ts.createDiagnosticForNodeInSourceFile(ts.getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2); + } + function bindSourceFile(f, opts) { + file = f; + options = opts; + languageVersion = ts.getEmitScriptTarget(options); + inStrictMode = bindInStrictMode(file, opts); + classifiableNames = ts.createUnderscoreEscapedMap(); + symbolCount = 0; + skipTransformFlagAggregation = file.isDeclarationFile; + Symbol = ts.objectAllocator.getSymbolConstructor(); + ts.Debug.attachFlowNodeDebugInfo(unreachableFlow); + ts.Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow); + if (!file.locals) { + bind(file); + file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; + delayedBindJSDocTypedefTag(); + } + file = undefined; + options = undefined; + languageVersion = undefined; + parent = undefined; + container = undefined; + thisParentContainer = undefined; + blockScopeContainer = undefined; + lastContainer = undefined; + delayedTypeAliases = undefined; + seenThisKeyword = false; + currentFlow = undefined; + currentBreakTarget = undefined; + currentContinueTarget = undefined; + currentReturnTarget = undefined; + currentTrueTarget = undefined; + currentFalseTarget = undefined; + currentExceptionTarget = undefined; + activeLabelList = undefined; + hasExplicitReturn = false; + emitFlags = 0; + subtreeTransformFlags = 0; + } + return bindSourceFile; + function bindInStrictMode(file, opts) { + if (ts.getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) { + return true; + } + else { + return !!file.externalModuleIndicator; + } + } + function createSymbol(flags, name) { + symbolCount++; + return new Symbol(flags, name); + } + function addDeclarationToSymbol(symbol, node, symbolFlags) { + symbol.flags |= symbolFlags; + node.symbol = symbol; + symbol.declarations = ts.appendIfUnique(symbol.declarations, node); + if (symbolFlags & (32 | 384 | 1536 | 3) && !symbol.exports) { + symbol.exports = ts.createSymbolTable(); + } + if (symbolFlags & (32 | 64 | 2048 | 4096) && !symbol.members) { + symbol.members = ts.createSymbolTable(); + } + if (symbol.constEnumOnlyModule && (symbol.flags & (16 | 32 | 256))) { + symbol.constEnumOnlyModule = false; + } + if (symbolFlags & 111551) { + setValueDeclaration(symbol, node); + } + } + function setValueDeclaration(symbol, node) { + var valueDeclaration = symbol.valueDeclaration; + if (!valueDeclaration || + (ts.isAssignmentDeclaration(valueDeclaration) && !ts.isAssignmentDeclaration(node)) || + (valueDeclaration.kind !== node.kind && ts.isEffectiveModuleDeclaration(valueDeclaration))) { + symbol.valueDeclaration = node; + } + } + function getDeclarationName(node) { + if (node.kind === 259) { + return node.isExportEquals ? "export=" : "default"; + } + var name = ts.getNameOfDeclaration(node); + if (name) { + if (ts.isAmbientModule(node)) { + var moduleName = ts.getTextOfIdentifierOrLiteral(name); + return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + moduleName + "\""); + } + if (name.kind === 154) { + var nameExpression = name.expression; + if (ts.isStringOrNumericLiteralLike(nameExpression)) { + return ts.escapeLeadingUnderscores(nameExpression.text); + } + if (ts.isSignedNumericLiteral(nameExpression)) { + return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text; + } + ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); + return ts.getPropertyNameForKnownSymbolName(ts.idText(nameExpression.name)); + } + if (ts.isWellKnownSymbolSyntactically(name)) { + return ts.getPropertyNameForKnownSymbolName(ts.idText(name.name)); + } + if (ts.isPrivateIdentifier(name)) { + var containingClass = ts.getContainingClass(node); + if (!containingClass) { + return undefined; + } + var containingClassSymbol = containingClass.symbol; + return ts.getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText); + } + return ts.isPropertyNameLiteral(name) ? ts.getEscapedTextOfIdentifierOrLiteral(name) : undefined; + } + switch (node.kind) { + case 162: + return "__constructor"; + case 170: + case 165: + case 305: + return "__call"; + case 171: + case 166: + return "__new"; + case 167: + return "__index"; + case 260: + return "__export"; + case 290: + return "export="; + case 209: + if (ts.getAssignmentDeclarationKind(node) === 2) { + return "export="; + } + ts.Debug.fail("Unknown binary declaration kind"); + break; + case 300: + return (ts.isJSDocConstructSignature(node) ? "__new" : "__call"); + case 156: + ts.Debug.assert(node.parent.kind === 300, "Impossible parameter parent kind", function () { return "parent is: " + (ts.SyntaxKind ? ts.SyntaxKind[node.parent.kind] : node.parent.kind) + ", expected JSDocFunctionType"; }); + var functionType = node.parent; + var index = functionType.parameters.indexOf(node); + return "arg" + index; + } + } + function getDisplayName(node) { + return ts.isNamedDeclaration(node) ? ts.declarationNameToString(node.name) : ts.unescapeLeadingUnderscores(ts.Debug.assertDefined(getDeclarationName(node))); + } + function declareSymbol(symbolTable, parent, node, includes, excludes, isReplaceableByMethod) { + ts.Debug.assert(!ts.hasDynamicName(node)); + var isDefaultExport = ts.hasModifier(node, 512); + var name = isDefaultExport && parent ? "default" : getDeclarationName(node); + var symbol; + if (name === undefined) { + symbol = createSymbol(0, "__missing"); + } + else { + symbol = symbolTable.get(name); + if (includes & 2885600) { + classifiableNames.set(name, true); + } + if (!symbol) { + symbolTable.set(name, symbol = createSymbol(0, name)); + if (isReplaceableByMethod) + symbol.isReplaceableByMethod = true; + } + else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) { + return symbol; + } + else if (symbol.flags & excludes) { + if (symbol.isReplaceableByMethod) { + symbolTable.set(name, symbol = createSymbol(0, name)); + } + else if (!(includes & 3 && symbol.flags & 67108864)) { + if (ts.isNamedDeclaration(node)) { + node.name.parent = node; + } + var message_1 = symbol.flags & 2 + ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 + : ts.Diagnostics.Duplicate_identifier_0; + var messageNeedsName_1 = true; + if (symbol.flags & 384 || includes & 384) { + message_1 = ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations; + messageNeedsName_1 = false; + } + var multipleDefaultExports_1 = false; + if (ts.length(symbol.declarations)) { + if (isDefaultExport) { + message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports; + messageNeedsName_1 = false; + multipleDefaultExports_1 = true; + } + else { + if (symbol.declarations && symbol.declarations.length && + (node.kind === 259 && !node.isExportEquals)) { + message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports; + messageNeedsName_1 = false; + multipleDefaultExports_1 = true; + } + } + } + var relatedInformation_1 = []; + if (ts.isTypeAliasDeclaration(node) && ts.nodeIsMissing(node.type) && ts.hasModifier(node, 1) && symbol.flags & (2097152 | 788968 | 1920)) { + relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { " + ts.unescapeLeadingUnderscores(node.name.escapedText) + " }")); + } + var declarationName_1 = ts.getNameOfDeclaration(node) || node; + ts.forEach(symbol.declarations, function (declaration, index) { + var decl = ts.getNameOfDeclaration(declaration) || declaration; + var diag = createDiagnosticForNode(decl, message_1, messageNeedsName_1 ? getDisplayName(declaration) : undefined); + file.bindDiagnostics.push(multipleDefaultExports_1 ? ts.addRelatedInfo(diag, createDiagnosticForNode(declarationName_1, index === 0 ? ts.Diagnostics.Another_export_default_is_here : ts.Diagnostics.and_here)) : diag); + if (multipleDefaultExports_1) { + relatedInformation_1.push(createDiagnosticForNode(decl, ts.Diagnostics.The_first_export_default_is_here)); + } + }); + var diag = createDiagnosticForNode(declarationName_1, message_1, messageNeedsName_1 ? getDisplayName(node) : undefined); + file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInformation_1))); + symbol = createSymbol(0, name); + } + } + } + addDeclarationToSymbol(symbol, node, includes); + if (symbol.parent) { + ts.Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one"); + } + else { + symbol.parent = parent; + } + return symbol; + } + function declareModuleMember(node, symbolFlags, symbolExcludes) { + var hasExportModifier = ts.getCombinedModifierFlags(node) & 1; + if (symbolFlags & 2097152) { + if (node.kind === 263 || (node.kind === 253 && hasExportModifier)) { + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + } + else { + return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); + } + } + else { + if (ts.isJSDocTypeAlias(node)) + ts.Debug.assert(ts.isInJSFile(node)); + if ((!ts.isAmbientModule(node) && (hasExportModifier || container.flags & 64)) || ts.isJSDocTypeAlias(node)) { + if (!container.locals || (ts.hasModifier(node, 512) && !getDeclarationName(node))) { + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + } + var exportKind = symbolFlags & 111551 ? 1048576 : 0; + var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); + local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + node.localSymbol = local; + return local; + } + else { + return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); + } + } + } + function bindContainer(node, containerFlags) { + var saveContainer = container; + var saveThisParentContainer = thisParentContainer; + var savedBlockScopeContainer = blockScopeContainer; + if (containerFlags & 1) { + if (node.kind !== 202) { + thisParentContainer = container; + } + container = blockScopeContainer = node; + if (containerFlags & 32) { + container.locals = ts.createSymbolTable(); + } + addToContainerChain(container); + } + else if (containerFlags & 2) { + blockScopeContainer = node; + blockScopeContainer.locals = undefined; + } + if (containerFlags & 4) { + var saveCurrentFlow = currentFlow; + var saveBreakTarget = currentBreakTarget; + var saveContinueTarget = currentContinueTarget; + var saveReturnTarget = currentReturnTarget; + var saveExceptionTarget = currentExceptionTarget; + var saveActiveLabelList = activeLabelList; + var saveHasExplicitReturn = hasExplicitReturn; + var isIIFE = containerFlags & 16 && !ts.hasModifier(node, 256) && + !node.asteriskToken && !!ts.getImmediatelyInvokedFunctionExpression(node); + if (!isIIFE) { + currentFlow = initFlowNode({ flags: 2 }); + if (containerFlags & (16 | 128)) { + currentFlow.node = node; + } + } + currentReturnTarget = isIIFE || node.kind === 162 ? createBranchLabel() : undefined; + currentExceptionTarget = undefined; + currentBreakTarget = undefined; + currentContinueTarget = undefined; + activeLabelList = undefined; + hasExplicitReturn = false; + bindChildren(node); + node.flags &= ~2816; + if (!(currentFlow.flags & 1) && containerFlags & 8 && ts.nodeIsPresent(node.body)) { + node.flags |= 256; + if (hasExplicitReturn) + node.flags |= 512; + node.endFlowNode = currentFlow; + } + if (node.kind === 290) { + node.flags |= emitFlags; + } + if (currentReturnTarget) { + addAntecedent(currentReturnTarget, currentFlow); + currentFlow = finishFlowLabel(currentReturnTarget); + if (node.kind === 162) { + node.returnFlowNode = currentFlow; + } + } + if (!isIIFE) { + currentFlow = saveCurrentFlow; + } + currentBreakTarget = saveBreakTarget; + currentContinueTarget = saveContinueTarget; + currentReturnTarget = saveReturnTarget; + currentExceptionTarget = saveExceptionTarget; + activeLabelList = saveActiveLabelList; + hasExplicitReturn = saveHasExplicitReturn; + } + else if (containerFlags & 64) { + seenThisKeyword = false; + bindChildren(node); + node.flags = seenThisKeyword ? node.flags | 128 : node.flags & ~128; + } + else { + bindChildren(node); + } + container = saveContainer; + thisParentContainer = saveThisParentContainer; + blockScopeContainer = savedBlockScopeContainer; + } + function bindChildren(node) { + if (skipTransformFlagAggregation) { + bindChildrenWorker(node); + } + else if (node.transformFlags & 536870912) { + skipTransformFlagAggregation = true; + bindChildrenWorker(node); + skipTransformFlagAggregation = false; + subtreeTransformFlags |= node.transformFlags & ~getTransformFlagsSubtreeExclusions(node.kind); + } + else { + var savedSubtreeTransformFlags = subtreeTransformFlags; + subtreeTransformFlags = 0; + bindChildrenWorker(node); + subtreeTransformFlags = savedSubtreeTransformFlags | computeTransformFlagsForNode(node, subtreeTransformFlags); + } + } + function bindEachFunctionsFirst(nodes) { + bindEach(nodes, function (n) { return n.kind === 244 ? bind(n) : undefined; }); + bindEach(nodes, function (n) { return n.kind !== 244 ? bind(n) : undefined; }); + } + function bindEach(nodes, bindFunction) { + if (bindFunction === void 0) { bindFunction = bind; } + if (nodes === undefined) { + return; + } + if (skipTransformFlagAggregation) { + ts.forEach(nodes, bindFunction); + } + else { + var savedSubtreeTransformFlags = subtreeTransformFlags; + subtreeTransformFlags = 0; + var nodeArrayFlags = 0; + for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) { + var node = nodes_2[_i]; + bindFunction(node); + nodeArrayFlags |= node.transformFlags & ~536870912; + } + nodes.transformFlags = nodeArrayFlags | 536870912; + subtreeTransformFlags |= savedSubtreeTransformFlags; + } + } + function bindEachChild(node) { + ts.forEachChild(node, bind, bindEach); + } + function bindChildrenWorker(node) { + if (checkUnreachable(node)) { + bindEachChild(node); + bindJSDoc(node); + return; + } + if (node.kind >= 225 && node.kind <= 241 && !options.allowUnreachableCode) { + node.flowNode = currentFlow; + } + switch (node.kind) { + case 229: + bindWhileStatement(node); + break; + case 228: + bindDoStatement(node); + break; + case 230: + bindForStatement(node); + break; + case 231: + case 232: + bindForInOrForOfStatement(node); + break; + case 227: + bindIfStatement(node); + break; + case 235: + case 239: + bindReturnOrThrow(node); + break; + case 234: + case 233: + bindBreakOrContinueStatement(node); + break; + case 240: + bindTryStatement(node); + break; + case 237: + bindSwitchStatement(node); + break; + case 251: + bindCaseBlock(node); + break; + case 277: + bindCaseClause(node); + break; + case 226: + bindExpressionStatement(node); + break; + case 238: + bindLabeledStatement(node); + break; + case 207: + bindPrefixUnaryExpressionFlow(node); + break; + case 208: + bindPostfixUnaryExpressionFlow(node); + break; + case 209: + bindBinaryExpressionFlow(node); + break; + case 203: + bindDeleteExpressionFlow(node); + break; + case 210: + bindConditionalExpressionFlow(node); + break; + case 242: + bindVariableDeclarationFlow(node); + break; + case 194: + case 195: + bindAccessExpressionFlow(node); + break; + case 196: + bindCallExpressionFlow(node); + break; + case 321: + case 314: + case 315: + bindJSDocTypeAlias(node); + break; + case 290: { + bindEachFunctionsFirst(node.statements); + bind(node.endOfFileToken); + break; + } + case 223: + case 250: + bindEachFunctionsFirst(node.statements); + break; + default: + bindEachChild(node); + break; + } + bindJSDoc(node); + } + function isNarrowingExpression(expr) { + switch (expr.kind) { + case 75: + case 104: + case 194: + case 195: + return containsNarrowableReference(expr); + case 196: + return hasNarrowableArgument(expr); + case 200: + return isNarrowingExpression(expr.expression); + case 209: + return isNarrowingBinaryExpression(expr); + case 207: + return expr.operator === 53 && isNarrowingExpression(expr.operand); + case 204: + return isNarrowingExpression(expr.expression); + } + return false; + } + function isNarrowableReference(expr) { + return expr.kind === 75 || expr.kind === 104 || expr.kind === 102 || + (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || + ts.isElementAccessExpression(expr) && ts.isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression); + } + function containsNarrowableReference(expr) { + return isNarrowableReference(expr) || ts.isOptionalChain(expr) && containsNarrowableReference(expr.expression); + } + function hasNarrowableArgument(expr) { + if (expr.arguments) { + for (var _i = 0, _a = expr.arguments; _i < _a.length; _i++) { + var argument = _a[_i]; + if (containsNarrowableReference(argument)) { + return true; + } + } + } + if (expr.expression.kind === 194 && + containsNarrowableReference(expr.expression.expression)) { + return true; + } + return false; + } + function isNarrowingTypeofOperands(expr1, expr2) { + return ts.isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && ts.isStringLiteralLike(expr2); + } + function isNarrowableInOperands(left, right) { + return ts.isStringLiteralLike(left) && isNarrowingExpression(right); + } + function isNarrowingBinaryExpression(expr) { + switch (expr.operatorToken.kind) { + case 62: + return containsNarrowableReference(expr.left); + case 34: + case 35: + case 36: + case 37: + return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || + isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right); + case 98: + return isNarrowableOperand(expr.left); + case 97: + return isNarrowableInOperands(expr.left, expr.right); + case 27: + return isNarrowingExpression(expr.right); + } + return false; + } + function isNarrowableOperand(expr) { + switch (expr.kind) { + case 200: + return isNarrowableOperand(expr.expression); + case 209: + switch (expr.operatorToken.kind) { + case 62: + return isNarrowableOperand(expr.left); + case 27: + return isNarrowableOperand(expr.right); + } + } + return containsNarrowableReference(expr); + } + function createBranchLabel() { + return initFlowNode({ flags: 4, antecedents: undefined }); + } + function createLoopLabel() { + return initFlowNode({ flags: 8, antecedents: undefined }); + } + function setFlowNodeReferenced(flow) { + flow.flags |= flow.flags & 1024 ? 2048 : 1024; + } + function addAntecedent(label, antecedent) { + if (!(antecedent.flags & 1) && !ts.contains(label.antecedents, antecedent)) { + (label.antecedents || (label.antecedents = [])).push(antecedent); + setFlowNodeReferenced(antecedent); + } + } + function createFlowCondition(flags, antecedent, expression) { + if (antecedent.flags & 1) { + return antecedent; + } + if (!expression) { + return flags & 32 ? antecedent : unreachableFlow; + } + if ((expression.kind === 106 && flags & 64 || + expression.kind === 91 && flags & 32) && + !ts.isExpressionOfOptionalChainRoot(expression) && !ts.isNullishCoalesce(expression.parent)) { + return unreachableFlow; + } + if (!isNarrowingExpression(expression)) { + return antecedent; + } + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: flags, antecedent: antecedent, node: expression }); + } + function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) { + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: 128, antecedent: antecedent, switchStatement: switchStatement, clauseStart: clauseStart, clauseEnd: clauseEnd }); + } + function createFlowMutation(flags, antecedent, node) { + setFlowNodeReferenced(antecedent); + var result = initFlowNode({ flags: flags, antecedent: antecedent, node: node }); + if (currentExceptionTarget) { + addAntecedent(currentExceptionTarget, result); + } + return result; + } + function createFlowCall(antecedent, node) { + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: 512, antecedent: antecedent, node: node }); + } + function finishFlowLabel(flow) { + var antecedents = flow.antecedents; + if (!antecedents) { + return unreachableFlow; + } + if (antecedents.length === 1) { + return antecedents[0]; + } + return flow; + } + function isStatementCondition(node) { + var parent = node.parent; + switch (parent.kind) { + case 227: + case 229: + case 228: + return parent.expression === node; + case 230: + case 210: + return parent.condition === node; + } + return false; + } + function isLogicalExpression(node) { + while (true) { + if (node.kind === 200) { + node = node.expression; + } + else if (node.kind === 207 && node.operator === 53) { + node = node.operand; + } + else { + return node.kind === 209 && (node.operatorToken.kind === 55 || + node.operatorToken.kind === 56 || + node.operatorToken.kind === 60); + } + } + } + function isTopLevelLogicalExpression(node) { + while (ts.isParenthesizedExpression(node.parent) || + ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 53) { + node = node.parent; + } + return !isStatementCondition(node) && + !isLogicalExpression(node.parent) && + !(ts.isOptionalChain(node.parent) && node.parent.expression === node); + } + function doWithConditionalBranches(action, value, trueTarget, falseTarget) { + var savedTrueTarget = currentTrueTarget; + var savedFalseTarget = currentFalseTarget; + currentTrueTarget = trueTarget; + currentFalseTarget = falseTarget; + action(value); + currentTrueTarget = savedTrueTarget; + currentFalseTarget = savedFalseTarget; + } + function bindCondition(node, trueTarget, falseTarget) { + doWithConditionalBranches(bind, node, trueTarget, falseTarget); + if (!node || !isLogicalExpression(node) && !(ts.isOptionalChain(node) && ts.isOutermostOptionalChain(node))) { + addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node)); + } + } + function bindIterativeStatement(node, breakTarget, continueTarget) { + var saveBreakTarget = currentBreakTarget; + var saveContinueTarget = currentContinueTarget; + currentBreakTarget = breakTarget; + currentContinueTarget = continueTarget; + bind(node); + currentBreakTarget = saveBreakTarget; + currentContinueTarget = saveContinueTarget; + } + function setContinueTarget(node, target) { + var label = activeLabelList; + while (label && node.parent.kind === 238) { + label.continueTarget = target; + label = label.next; + node = node.parent; + } + return target; + } + function bindWhileStatement(node) { + var preWhileLabel = setContinueTarget(node, createLoopLabel()); + var preBodyLabel = createBranchLabel(); + var postWhileLabel = createBranchLabel(); + addAntecedent(preWhileLabel, currentFlow); + currentFlow = preWhileLabel; + bindCondition(node.expression, preBodyLabel, postWhileLabel); + currentFlow = finishFlowLabel(preBodyLabel); + bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel); + addAntecedent(preWhileLabel, currentFlow); + currentFlow = finishFlowLabel(postWhileLabel); + } + function bindDoStatement(node) { + var preDoLabel = createLoopLabel(); + var preConditionLabel = setContinueTarget(node, createBranchLabel()); + var postDoLabel = createBranchLabel(); + addAntecedent(preDoLabel, currentFlow); + currentFlow = preDoLabel; + bindIterativeStatement(node.statement, postDoLabel, preConditionLabel); + addAntecedent(preConditionLabel, currentFlow); + currentFlow = finishFlowLabel(preConditionLabel); + bindCondition(node.expression, preDoLabel, postDoLabel); + currentFlow = finishFlowLabel(postDoLabel); + } + function bindForStatement(node) { + var preLoopLabel = setContinueTarget(node, createLoopLabel()); + var preBodyLabel = createBranchLabel(); + var postLoopLabel = createBranchLabel(); + bind(node.initializer); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = preLoopLabel; + bindCondition(node.condition, preBodyLabel, postLoopLabel); + currentFlow = finishFlowLabel(preBodyLabel); + bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); + bind(node.incrementor); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = finishFlowLabel(postLoopLabel); + } + function bindForInOrForOfStatement(node) { + var preLoopLabel = setContinueTarget(node, createLoopLabel()); + var postLoopLabel = createBranchLabel(); + bind(node.expression); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = preLoopLabel; + if (node.kind === 232) { + bind(node.awaitModifier); + } + addAntecedent(postLoopLabel, currentFlow); + bind(node.initializer); + if (node.initializer.kind !== 243) { + bindAssignmentTargetFlow(node.initializer); + } + bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = finishFlowLabel(postLoopLabel); + } + function bindIfStatement(node) { + var thenLabel = createBranchLabel(); + var elseLabel = createBranchLabel(); + var postIfLabel = createBranchLabel(); + bindCondition(node.expression, thenLabel, elseLabel); + currentFlow = finishFlowLabel(thenLabel); + bind(node.thenStatement); + addAntecedent(postIfLabel, currentFlow); + currentFlow = finishFlowLabel(elseLabel); + bind(node.elseStatement); + addAntecedent(postIfLabel, currentFlow); + currentFlow = finishFlowLabel(postIfLabel); + } + function bindReturnOrThrow(node) { + bind(node.expression); + if (node.kind === 235) { + hasExplicitReturn = true; + if (currentReturnTarget) { + addAntecedent(currentReturnTarget, currentFlow); + } + } + currentFlow = unreachableFlow; + } + function findActiveLabel(name) { + for (var label = activeLabelList; label; label = label.next) { + if (label.name === name) { + return label; + } + } + return undefined; + } + function bindBreakOrContinueFlow(node, breakTarget, continueTarget) { + var flowLabel = node.kind === 234 ? breakTarget : continueTarget; + if (flowLabel) { + addAntecedent(flowLabel, currentFlow); + currentFlow = unreachableFlow; + } + } + function bindBreakOrContinueStatement(node) { + bind(node.label); + if (node.label) { + var activeLabel = findActiveLabel(node.label.escapedText); + if (activeLabel) { + activeLabel.referenced = true; + bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget); + } + } + else { + bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget); + } + } + function bindTryStatement(node) { + var preFinallyLabel = createBranchLabel(); + var saveReturnTarget = currentReturnTarget; + var saveExceptionTarget = currentExceptionTarget; + currentReturnTarget = createBranchLabel(); + currentExceptionTarget = node.catchClause ? createBranchLabel() : currentReturnTarget; + addAntecedent(currentExceptionTarget, currentFlow); + bind(node.tryBlock); + addAntecedent(preFinallyLabel, currentFlow); + var flowAfterTry = currentFlow; + var flowAfterCatch = unreachableFlow; + if (node.catchClause) { + currentFlow = finishFlowLabel(currentExceptionTarget); + currentExceptionTarget = currentReturnTarget; + addAntecedent(currentExceptionTarget, currentFlow); + bind(node.catchClause); + addAntecedent(preFinallyLabel, currentFlow); + flowAfterCatch = currentFlow; + } + var exceptionTarget = finishFlowLabel(currentExceptionTarget); + currentReturnTarget = saveReturnTarget; + currentExceptionTarget = saveExceptionTarget; + if (node.finallyBlock) { + var preFinallyFlow = initFlowNode({ flags: 4096, antecedent: exceptionTarget, lock: {} }); + addAntecedent(preFinallyLabel, preFinallyFlow); + currentFlow = finishFlowLabel(preFinallyLabel); + bind(node.finallyBlock); + if (!(currentFlow.flags & 1)) { + if ((flowAfterTry.flags & 1) && (flowAfterCatch.flags & 1)) { + currentFlow = flowAfterTry === reportedUnreachableFlow || flowAfterCatch === reportedUnreachableFlow + ? reportedUnreachableFlow + : unreachableFlow; + } + } + if (!(currentFlow.flags & 1)) { + var afterFinallyFlow = initFlowNode({ flags: 8192, antecedent: currentFlow }); + preFinallyFlow.lock = afterFinallyFlow; + currentFlow = afterFinallyFlow; + } + } + else { + currentFlow = finishFlowLabel(preFinallyLabel); + } + } + function bindSwitchStatement(node) { + var postSwitchLabel = createBranchLabel(); + bind(node.expression); + var saveBreakTarget = currentBreakTarget; + var savePreSwitchCaseFlow = preSwitchCaseFlow; + currentBreakTarget = postSwitchLabel; + preSwitchCaseFlow = currentFlow; + bind(node.caseBlock); + addAntecedent(postSwitchLabel, currentFlow); + var hasDefault = ts.forEach(node.caseBlock.clauses, function (c) { return c.kind === 278; }); + node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents; + if (!hasDefault) { + addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0)); + } + currentBreakTarget = saveBreakTarget; + preSwitchCaseFlow = savePreSwitchCaseFlow; + currentFlow = finishFlowLabel(postSwitchLabel); + } + function bindCaseBlock(node) { + var savedSubtreeTransformFlags = subtreeTransformFlags; + subtreeTransformFlags = 0; + var clauses = node.clauses; + var isNarrowingSwitch = isNarrowingExpression(node.parent.expression); + var fallthroughFlow = unreachableFlow; + for (var i = 0; i < clauses.length; i++) { + var clauseStart = i; + while (!clauses[i].statements.length && i + 1 < clauses.length) { + bind(clauses[i]); + i++; + } + var preCaseLabel = createBranchLabel(); + addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow); + addAntecedent(preCaseLabel, fallthroughFlow); + currentFlow = finishFlowLabel(preCaseLabel); + var clause = clauses[i]; + bind(clause); + fallthroughFlow = currentFlow; + if (!(currentFlow.flags & 1) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) { + clause.fallthroughFlowNode = currentFlow; + } + } + clauses.transformFlags = subtreeTransformFlags | 536870912; + subtreeTransformFlags |= savedSubtreeTransformFlags; + } + function bindCaseClause(node) { + var saveCurrentFlow = currentFlow; + currentFlow = preSwitchCaseFlow; + bind(node.expression); + currentFlow = saveCurrentFlow; + bindEach(node.statements); + } + function bindExpressionStatement(node) { + bind(node.expression); + if (node.expression.kind === 196) { + var call = node.expression; + if (ts.isDottedName(call.expression)) { + currentFlow = createFlowCall(currentFlow, call); + } + } + } + function bindLabeledStatement(node) { + var postStatementLabel = createBranchLabel(); + activeLabelList = { + next: activeLabelList, + name: node.label.escapedText, + breakTarget: postStatementLabel, + continueTarget: undefined, + referenced: false + }; + bind(node.label); + bind(node.statement); + if (!activeLabelList.referenced && !options.allowUnusedLabels) { + errorOrSuggestionOnNode(ts.unusedLabelIsError(options), node.label, ts.Diagnostics.Unused_label); + } + activeLabelList = activeLabelList.next; + addAntecedent(postStatementLabel, currentFlow); + currentFlow = finishFlowLabel(postStatementLabel); + } + function bindDestructuringTargetFlow(node) { + if (node.kind === 209 && node.operatorToken.kind === 62) { + bindAssignmentTargetFlow(node.left); + } + else { + bindAssignmentTargetFlow(node); + } + } + function bindAssignmentTargetFlow(node) { + if (isNarrowableReference(node)) { + currentFlow = createFlowMutation(16, currentFlow, node); + } + else if (node.kind === 192) { + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var e = _a[_i]; + if (e.kind === 213) { + bindAssignmentTargetFlow(e.expression); + } + else { + bindDestructuringTargetFlow(e); + } + } + } + else if (node.kind === 193) { + for (var _b = 0, _c = node.properties; _b < _c.length; _b++) { + var p = _c[_b]; + if (p.kind === 281) { + bindDestructuringTargetFlow(p.initializer); + } + else if (p.kind === 282) { + bindAssignmentTargetFlow(p.name); + } + else if (p.kind === 283) { + bindAssignmentTargetFlow(p.expression); + } + } + } + } + function bindLogicalExpression(node, trueTarget, falseTarget) { + var preRightLabel = createBranchLabel(); + if (node.operatorToken.kind === 55) { + bindCondition(node.left, preRightLabel, falseTarget); + } + else { + bindCondition(node.left, trueTarget, preRightLabel); + } + currentFlow = finishFlowLabel(preRightLabel); + bind(node.operatorToken); + bindCondition(node.right, trueTarget, falseTarget); + } + function bindPrefixUnaryExpressionFlow(node) { + if (node.operator === 53) { + var saveTrueTarget = currentTrueTarget; + currentTrueTarget = currentFalseTarget; + currentFalseTarget = saveTrueTarget; + bindEachChild(node); + currentFalseTarget = currentTrueTarget; + currentTrueTarget = saveTrueTarget; + } + else { + bindEachChild(node); + if (node.operator === 45 || node.operator === 46) { + bindAssignmentTargetFlow(node.operand); + } + } + } + function bindPostfixUnaryExpressionFlow(node) { + bindEachChild(node); + if (node.operator === 45 || node.operator === 46) { + bindAssignmentTargetFlow(node.operand); + } + } + function bindBinaryExpressionFlow(node) { + var workStacks = { + expr: [node], + state: [1], + inStrictMode: [undefined], + parent: [undefined], + subtreeFlags: [undefined] + }; + var stackIndex = 0; + while (stackIndex >= 0) { + node = workStacks.expr[stackIndex]; + switch (workStacks.state[stackIndex]) { + case 0: { + node.parent = parent; + var saveInStrictMode = inStrictMode; + bindWorker(node); + var saveParent = parent; + parent = node; + var subtreeFlagsState = void 0; + if (skipTransformFlagAggregation) { + } + else if (node.transformFlags & 536870912) { + skipTransformFlagAggregation = true; + subtreeFlagsState = -1; + } + else { + var savedSubtreeTransformFlags = subtreeTransformFlags; + subtreeTransformFlags = 0; + subtreeFlagsState = savedSubtreeTransformFlags; + } + advanceState(1, saveInStrictMode, saveParent, subtreeFlagsState); + break; + } + case 1: { + var operator = node.operatorToken.kind; + if (operator === 55 || operator === 56 || operator === 60) { + if (isTopLevelLogicalExpression(node)) { + var postExpressionLabel = createBranchLabel(); + bindLogicalExpression(node, postExpressionLabel, postExpressionLabel); + currentFlow = finishFlowLabel(postExpressionLabel); + } + else { + bindLogicalExpression(node, currentTrueTarget, currentFalseTarget); + } + completeNode(); + } + else { + advanceState(2); + maybeBind(node.left); + } + break; + } + case 2: { + advanceState(3); + maybeBind(node.operatorToken); + break; + } + case 3: { + advanceState(4); + maybeBind(node.right); + break; + } + case 4: { + var operator = node.operatorToken.kind; + if (ts.isAssignmentOperator(operator) && !ts.isAssignmentTarget(node)) { + bindAssignmentTargetFlow(node.left); + if (operator === 62 && node.left.kind === 195) { + var elementAccess = node.left; + if (isNarrowableOperand(elementAccess.expression)) { + currentFlow = createFlowMutation(256, currentFlow, node); + } + } + } + completeNode(); + break; + } + default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for bindBinaryExpressionFlow"); + } + } + function advanceState(state, isInStrictMode, parent, subtreeFlags) { + workStacks.state[stackIndex] = state; + if (isInStrictMode !== undefined) { + workStacks.inStrictMode[stackIndex] = isInStrictMode; + } + if (parent !== undefined) { + workStacks.parent[stackIndex] = parent; + } + if (subtreeFlags !== undefined) { + workStacks.subtreeFlags[stackIndex] = subtreeFlags; + } + } + function completeNode() { + if (workStacks.inStrictMode[stackIndex] !== undefined) { + if (workStacks.subtreeFlags[stackIndex] === -1) { + skipTransformFlagAggregation = false; + subtreeTransformFlags |= node.transformFlags & ~getTransformFlagsSubtreeExclusions(node.kind); + } + else if (workStacks.subtreeFlags[stackIndex] !== undefined) { + subtreeTransformFlags = workStacks.subtreeFlags[stackIndex] | computeTransformFlagsForNode(node, subtreeTransformFlags); + } + inStrictMode = workStacks.inStrictMode[stackIndex]; + parent = workStacks.parent[stackIndex]; + } + stackIndex--; + } + function maybeBind(node) { + if (node && ts.isBinaryExpression(node)) { + stackIndex++; + workStacks.expr[stackIndex] = node; + workStacks.state[stackIndex] = 0; + workStacks.inStrictMode[stackIndex] = undefined; + workStacks.parent[stackIndex] = undefined; + workStacks.subtreeFlags[stackIndex] = undefined; + } + else { + bind(node); + } + } + } + function bindDeleteExpressionFlow(node) { + bindEachChild(node); + if (node.expression.kind === 194) { + bindAssignmentTargetFlow(node.expression); + } + } + function bindConditionalExpressionFlow(node) { + var trueLabel = createBranchLabel(); + var falseLabel = createBranchLabel(); + var postExpressionLabel = createBranchLabel(); + bindCondition(node.condition, trueLabel, falseLabel); + currentFlow = finishFlowLabel(trueLabel); + bind(node.questionToken); + bind(node.whenTrue); + addAntecedent(postExpressionLabel, currentFlow); + currentFlow = finishFlowLabel(falseLabel); + bind(node.colonToken); + bind(node.whenFalse); + addAntecedent(postExpressionLabel, currentFlow); + currentFlow = finishFlowLabel(postExpressionLabel); + } + function bindInitializedVariableFlow(node) { + var name = !ts.isOmittedExpression(node) ? node.name : undefined; + if (ts.isBindingPattern(name)) { + for (var _i = 0, _a = name.elements; _i < _a.length; _i++) { + var child = _a[_i]; + bindInitializedVariableFlow(child); + } + } + else { + currentFlow = createFlowMutation(16, currentFlow, node); + } + } + function bindVariableDeclarationFlow(node) { + bindEachChild(node); + if (node.initializer || ts.isForInOrOfStatement(node.parent.parent)) { + bindInitializedVariableFlow(node); + } + } + function bindJSDocTypeAlias(node) { + node.tagName.parent = node; + if (node.kind !== 315 && node.fullName) { + setParentPointers(node, node.fullName); + } + } + function bindJSDocClassTag(node) { + bindEachChild(node); + var host = ts.getHostSignatureFromJSDoc(node); + if (host && host.kind !== 161) { + addDeclarationToSymbol(host.symbol, host, 32); + } + } + function bindOptionalExpression(node, trueTarget, falseTarget) { + doWithConditionalBranches(bind, node, trueTarget, falseTarget); + if (!ts.isOptionalChain(node) || ts.isOutermostOptionalChain(node)) { + addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node)); + } + } + function bindOptionalChainRest(node) { + bind(node.questionDotToken); + switch (node.kind) { + case 194: + bind(node.name); + break; + case 195: + bind(node.argumentExpression); + break; + case 196: + bindEach(node.typeArguments); + bindEach(node.arguments); + break; + } + } + function bindOptionalChain(node, trueTarget, falseTarget) { + var preChainLabel = node.questionDotToken ? createBranchLabel() : undefined; + bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget); + if (preChainLabel) { + currentFlow = finishFlowLabel(preChainLabel); + } + doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget); + if (ts.isOutermostOptionalChain(node)) { + addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node)); + } + } + function bindOptionalChainFlow(node) { + if (isTopLevelLogicalExpression(node)) { + var postExpressionLabel = createBranchLabel(); + bindOptionalChain(node, postExpressionLabel, postExpressionLabel); + currentFlow = finishFlowLabel(postExpressionLabel); + } + else { + bindOptionalChain(node, currentTrueTarget, currentFalseTarget); + } + } + function bindAccessExpressionFlow(node) { + if (ts.isOptionalChain(node)) { + bindOptionalChainFlow(node); + } + else { + bindEachChild(node); + } + } + function bindCallExpressionFlow(node) { + if (ts.isOptionalChain(node)) { + bindOptionalChainFlow(node); + } + else { + var expr = ts.skipParentheses(node.expression); + if (expr.kind === 201 || expr.kind === 202) { + bindEach(node.typeArguments); + bindEach(node.arguments); + bind(node.expression); + } + else { + bindEachChild(node); + } + } + if (node.expression.kind === 194) { + var propertyAccess = node.expression; + if (ts.isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && ts.isPushOrUnshiftIdentifier(propertyAccess.name)) { + currentFlow = createFlowMutation(256, currentFlow, node); + } + } + } + function getContainerFlags(node) { + switch (node.kind) { + case 214: + case 245: + case 248: + case 193: + case 173: + case 304: + case 274: + return 1; + case 246: + return 1 | 64; + case 249: + case 247: + case 186: + return 1 | 32; + case 290: + return 1 | 4 | 32; + case 161: + if (ts.isObjectLiteralOrClassExpressionMethod(node)) { + return 1 | 4 | 32 | 8 | 128; + } + case 162: + case 244: + case 160: + case 163: + case 164: + case 165: + case 305: + case 300: + case 170: + case 166: + case 167: + case 171: + return 1 | 4 | 32 | 8; + case 201: + case 202: + return 1 | 4 | 32 | 8 | 16; + case 250: + return 4; + case 159: + return node.initializer ? 4 : 0; + case 280: + case 230: + case 231: + case 232: + case 251: + return 2; + case 223: + return ts.isFunctionLike(node.parent) ? 0 : 2; + } + return 0; + } + function addToContainerChain(next) { + if (lastContainer) { + lastContainer.nextContainer = next; + } + lastContainer = next; + } + function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) { + switch (container.kind) { + case 249: + return declareModuleMember(node, symbolFlags, symbolExcludes); + case 290: + return declareSourceFileMember(node, symbolFlags, symbolExcludes); + case 214: + case 245: + return declareClassMember(node, symbolFlags, symbolExcludes); + case 248: + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + case 173: + case 304: + case 193: + case 246: + case 274: + return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); + case 170: + case 171: + case 165: + case 166: + case 305: + case 167: + case 161: + case 160: + case 162: + case 163: + case 164: + case 244: + case 201: + case 202: + case 300: + case 321: + case 314: + case 247: + case 186: + return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); + } + } + function declareClassMember(node, symbolFlags, symbolExcludes) { + return ts.hasModifier(node, 32) + ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes) + : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); + } + function declareSourceFileMember(node, symbolFlags, symbolExcludes) { + return ts.isExternalModule(file) + ? declareModuleMember(node, symbolFlags, symbolExcludes) + : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes); + } + function hasExportDeclarations(node) { + var body = ts.isSourceFile(node) ? node : ts.tryCast(node.body, ts.isModuleBlock); + return !!body && body.statements.some(function (s) { return ts.isExportDeclaration(s) || ts.isExportAssignment(s); }); + } + function setExportContextFlag(node) { + if (node.flags & 8388608 && !hasExportDeclarations(node)) { + node.flags |= 64; + } + else { + node.flags &= ~64; + } + } + function bindModuleDeclaration(node) { + setExportContextFlag(node); + if (ts.isAmbientModule(node)) { + if (ts.hasModifier(node, 1)) { + errorOnFirstToken(node, ts.Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible); + } + if (ts.isModuleAugmentationExternal(node)) { + declareModuleSymbol(node); + } + else { + var pattern = void 0; + if (node.name.kind === 10) { + var text = node.name.text; + if (ts.hasZeroOrOneAsteriskCharacter(text)) { + pattern = ts.tryParsePattern(text); + } + else { + errorOnFirstToken(node.name, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text); + } + } + var symbol = declareSymbolAndAddToSymbolTable(node, 512, 110735); + file.patternAmbientModules = ts.append(file.patternAmbientModules, pattern && { pattern: pattern, symbol: symbol }); + } + } + else { + var state = declareModuleSymbol(node); + if (state !== 0) { + var symbol = node.symbol; + symbol.constEnumOnlyModule = (!(symbol.flags & (16 | 32 | 256))) + && state === 2 + && symbol.constEnumOnlyModule !== false; + } + } + } + function declareModuleSymbol(node) { + var state = getModuleInstanceState(node); + var instantiated = state !== 0; + declareSymbolAndAddToSymbolTable(node, instantiated ? 512 : 1024, instantiated ? 110735 : 0); + return state; + } + function bindFunctionOrConstructorType(node) { + var symbol = createSymbol(131072, getDeclarationName(node)); + addDeclarationToSymbol(symbol, node, 131072); + var typeLiteralSymbol = createSymbol(2048, "__type"); + addDeclarationToSymbol(typeLiteralSymbol, node, 2048); + typeLiteralSymbol.members = ts.createSymbolTable(); + typeLiteralSymbol.members.set(symbol.escapedName, symbol); + } + function bindObjectLiteralExpression(node) { + if (inStrictMode && !ts.isAssignmentTarget(node)) { + var seen = ts.createUnderscoreEscapedMap(); + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.kind === 283 || prop.name.kind !== 75) { + continue; + } + var identifier = prop.name; + var currentKind = prop.kind === 281 || prop.kind === 282 || prop.kind === 161 + ? 1 + : 2; + var existingKind = seen.get(identifier.escapedText); + if (!existingKind) { + seen.set(identifier.escapedText, currentKind); + continue; + } + if (currentKind === 1 && existingKind === 1) { + var span = ts.getErrorSpanForNode(file, identifier); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode)); + } + } + } + return bindAnonymousDeclaration(node, 4096, "__object"); + } + function bindJsxAttributes(node) { + return bindAnonymousDeclaration(node, 4096, "__jsxAttributes"); + } + function bindJsxAttribute(node, symbolFlags, symbolExcludes) { + return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes); + } + function bindAnonymousDeclaration(node, symbolFlags, name) { + var symbol = createSymbol(symbolFlags, name); + if (symbolFlags & (8 | 106500)) { + symbol.parent = container.symbol; + } + addDeclarationToSymbol(symbol, node, symbolFlags); + return symbol; + } + function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { + switch (blockScopeContainer.kind) { + case 249: + declareModuleMember(node, symbolFlags, symbolExcludes); + break; + case 290: + if (ts.isExternalOrCommonJsModule(container)) { + declareModuleMember(node, symbolFlags, symbolExcludes); + break; + } + default: + if (!blockScopeContainer.locals) { + blockScopeContainer.locals = ts.createSymbolTable(); + addToContainerChain(blockScopeContainer); + } + declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes); + } + } + function delayedBindJSDocTypedefTag() { + if (!delayedTypeAliases) { + return; + } + var saveContainer = container; + var saveLastContainer = lastContainer; + var saveBlockScopeContainer = blockScopeContainer; + var saveParent = parent; + var saveCurrentFlow = currentFlow; + for (var _i = 0, delayedTypeAliases_1 = delayedTypeAliases; _i < delayedTypeAliases_1.length; _i++) { + var typeAlias = delayedTypeAliases_1[_i]; + var host = ts.getJSDocHost(typeAlias); + container = ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1); }) || file; + blockScopeContainer = ts.getEnclosingBlockScopeContainer(host) || file; + currentFlow = initFlowNode({ flags: 2 }); + parent = typeAlias; + bind(typeAlias.typeExpression); + var declName = ts.getNameOfDeclaration(typeAlias); + if ((ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && ts.isPropertyAccessEntityNameExpression(declName.parent)) { + var isTopLevel = isTopLevelNamespaceAssignment(declName.parent); + if (isTopLevel) { + bindPotentiallyMissingNamespaces(file.symbol, declName.parent, isTopLevel, !!ts.findAncestor(declName, function (d) { return ts.isPropertyAccessExpression(d) && d.name.escapedText === "prototype"; }), false); + var oldContainer = container; + switch (ts.getAssignmentDeclarationPropertyAccessKind(declName.parent)) { + case 1: + case 2: + if (!ts.isExternalOrCommonJsModule(file)) { + container = undefined; + } + else { + container = file; + } + break; + case 4: + container = declName.parent.expression; + break; + case 3: + container = declName.parent.expression.name; + break; + case 5: + container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file + : ts.isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name + : declName.parent.expression; + break; + case 0: + return ts.Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration"); + } + if (container) { + declareModuleMember(typeAlias, 524288, 788968); + } + container = oldContainer; + } + } + else if (ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 75) { + parent = typeAlias.parent; + bindBlockScopedDeclaration(typeAlias, 524288, 788968); + } + else { + bind(typeAlias.fullName); + } + } + container = saveContainer; + lastContainer = saveLastContainer; + blockScopeContainer = saveBlockScopeContainer; + parent = saveParent; + currentFlow = saveCurrentFlow; + } + function checkStrictModeIdentifier(node) { + if (inStrictMode && + node.originalKeywordKind >= 113 && + node.originalKeywordKind <= 121 && + !ts.isIdentifierName(node) && + !(node.flags & 8388608) && + !(node.flags & 4194304)) { + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function checkPrivateIdentifier(node) { + if (node.escapedText === "#constructor") { + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.constructor_is_a_reserved_word, ts.declarationNameToString(node))); + } + } + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + if (inStrictMode && node.expression.kind === 75) { + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return ts.isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 75) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), ts.idText(identifier))); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } + } + function getStrictModeBlockScopeFunctionDeclarationMessage(node) { + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5; + } + function checkStrictModeFunctionDeclaration(node) { + if (languageVersion < 2) { + if (blockScopeContainer.kind !== 290 && + blockScopeContainer.kind !== 249 && + !ts.isFunctionLike(blockScopeContainer)) { + var errorSpan = ts.getErrorSpanForNode(file, node); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, errorSpan.start, errorSpan.length, getStrictModeBlockScopeFunctionDeclarationMessage(node))); + } + } + } + function checkStrictModeNumericLiteral(node) { + if (inStrictMode && node.numericLiteralFlags & 32) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + if (inStrictMode) { + if (node.operator === 45 || node.operator === 46) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + if (inStrictMode) { + errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function checkStrictModeLabeledStatement(node) { + if (inStrictMode && options.target >= 2) { + if (ts.isDeclarationStatement(node.statement) || ts.isVariableStatement(node.statement)) { + errorOnFirstToken(node.label, ts.Diagnostics.A_label_is_not_allowed_here); + } + } + } + function errorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } + function errorOrSuggestionOnNode(isError, node, message) { + errorOrSuggestionOnRange(isError, node, node, message); + } + function errorOrSuggestionOnRange(isError, startNode, endNode, message) { + addErrorOrSuggestionDiagnostic(isError, { pos: ts.getTokenPosOfNode(startNode, file), end: endNode.end }, message); + } + function addErrorOrSuggestionDiagnostic(isError, range, message) { + var diag = ts.createFileDiagnostic(file, range.pos, range.end - range.pos, message); + if (isError) { + file.bindDiagnostics.push(diag); + } + else { + file.bindSuggestionDiagnostics = ts.append(file.bindSuggestionDiagnostics, __assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion })); + } + } + function bind(node) { + if (!node) { + return; + } + node.parent = parent; + var saveInStrictMode = inStrictMode; + bindWorker(node); + if (node.kind > 152) { + var saveParent = parent; + parent = node; + var containerFlags = getContainerFlags(node); + if (containerFlags === 0) { + bindChildren(node); + } + else { + bindContainer(node, containerFlags); + } + parent = saveParent; + } + else if (!skipTransformFlagAggregation && (node.transformFlags & 536870912) === 0) { + subtreeTransformFlags |= computeTransformFlagsForNode(node, 0); + var saveParent = parent; + if (node.kind === 1) + parent = node; + bindJSDoc(node); + parent = saveParent; + } + inStrictMode = saveInStrictMode; + } + function bindJSDoc(node) { + if (ts.hasJSDocNodes(node)) { + if (ts.isInJSFile(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var j = _a[_i]; + bind(j); + } + } + else { + for (var _b = 0, _c = node.jsDoc; _b < _c.length; _b++) { + var j = _c[_b]; + setParentPointers(node, j); + } + } + } + } + function updateStrictModeStatementList(statements) { + if (!inStrictMode) { + for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) { + var statement = statements_2[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + } + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getSourceTextOfNodeFromSourceFile(file, node.expression); + return nodeText === '"use strict"' || nodeText === "'use strict'"; + } + function bindWorker(node) { + switch (node.kind) { + case 75: + if (node.isInJSDocNamespace) { + var parentNode = node.parent; + while (parentNode && !ts.isJSDocTypeAlias(parentNode)) { + parentNode = parentNode.parent; + } + bindBlockScopedDeclaration(parentNode, 524288, 788968); + break; + } + case 104: + if (currentFlow && (ts.isExpression(node) || parent.kind === 282)) { + node.flowNode = currentFlow; + } + return checkStrictModeIdentifier(node); + case 76: + return checkPrivateIdentifier(node); + case 194: + case 195: + var expr = node; + if (currentFlow && isNarrowableReference(expr)) { + expr.flowNode = currentFlow; + } + if (ts.isSpecialPropertyDeclaration(expr)) { + bindSpecialPropertyDeclaration(expr); + } + if (ts.isInJSFile(expr) && + file.commonJsModuleIndicator && + ts.isModuleExportsAccessExpression(expr) && + !lookupSymbolForNameWorker(blockScopeContainer, "module")) { + declareSymbol(file.locals, undefined, expr.expression, 1 | 134217728, 111550); + } + break; + case 209: + var specialKind = ts.getAssignmentDeclarationKind(node); + switch (specialKind) { + case 1: + bindExportsPropertyAssignment(node); + break; + case 2: + bindModuleExportsAssignment(node); + break; + case 3: + bindPrototypePropertyAssignment(node.left, node); + break; + case 6: + bindPrototypeAssignment(node); + break; + case 4: + bindThisPropertyAssignment(node); + break; + case 5: + bindSpecialPropertyAssignment(node); + break; + case 0: + break; + default: + ts.Debug.fail("Unknown binary expression special property assignment kind"); + } + return checkStrictModeBinaryExpression(node); + case 280: + return checkStrictModeCatchClause(node); + case 203: + return checkStrictModeDeleteExpression(node); + case 8: + return checkStrictModeNumericLiteral(node); + case 208: + return checkStrictModePostfixUnaryExpression(node); + case 207: + return checkStrictModePrefixUnaryExpression(node); + case 236: + return checkStrictModeWithStatement(node); + case 238: + return checkStrictModeLabeledStatement(node); + case 183: + seenThisKeyword = true; + return; + case 168: + break; + case 155: + return bindTypeParameter(node); + case 156: + return bindParameter(node); + case 242: + return bindVariableDeclarationOrBindingElement(node); + case 191: + node.flowNode = currentFlow; + return bindVariableDeclarationOrBindingElement(node); + case 159: + case 158: + return bindPropertyWorker(node); + case 281: + case 282: + return bindPropertyOrMethodOrAccessor(node, 4, 0); + case 284: + return bindPropertyOrMethodOrAccessor(node, 8, 900095); + case 165: + case 166: + case 167: + return declareSymbolAndAddToSymbolTable(node, 131072, 0); + case 161: + case 160: + return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 16777216 : 0), ts.isObjectLiteralMethod(node) ? 0 : 103359); + case 244: + return bindFunctionDeclaration(node); + case 162: + return declareSymbolAndAddToSymbolTable(node, 16384, 0); + case 163: + return bindPropertyOrMethodOrAccessor(node, 32768, 46015); + case 164: + return bindPropertyOrMethodOrAccessor(node, 65536, 78783); + case 170: + case 300: + case 305: + case 171: + return bindFunctionOrConstructorType(node); + case 173: + case 304: + case 186: + return bindAnonymousTypeWorker(node); + case 309: + return bindJSDocClassTag(node); + case 193: + return bindObjectLiteralExpression(node); + case 201: + case 202: + return bindFunctionExpression(node); + case 196: + var assignmentKind = ts.getAssignmentDeclarationKind(node); + switch (assignmentKind) { + case 7: + return bindObjectDefinePropertyAssignment(node); + case 8: + return bindObjectDefinePropertyExport(node); + case 9: + return bindObjectDefinePrototypeProperty(node); + case 0: + break; + default: + return ts.Debug.fail("Unknown call expression assignment declaration kind"); + } + if (ts.isInJSFile(node)) { + bindCallExpression(node); + } + break; + case 214: + case 245: + inStrictMode = true; + return bindClassLikeDeclaration(node); + case 246: + return bindBlockScopedDeclaration(node, 64, 788872); + case 247: + return bindBlockScopedDeclaration(node, 524288, 788968); + case 248: + return bindEnumDeclaration(node); + case 249: + return bindModuleDeclaration(node); + case 274: + return bindJsxAttributes(node); + case 273: + return bindJsxAttribute(node, 4, 0); + case 253: + case 256: + case 258: + case 263: + return declareSymbolAndAddToSymbolTable(node, 2097152, 2097152); + case 252: + return bindNamespaceExportDeclaration(node); + case 255: + return bindImportClause(node); + case 260: + return bindExportDeclaration(node); + case 259: + return bindExportAssignment(node); + case 290: + updateStrictModeStatementList(node.statements); + return bindSourceFileIfExternalModule(); + case 223: + if (!ts.isFunctionLike(node.parent)) { + return; + } + case 250: + return updateStrictModeStatementList(node.statements); + case 316: + if (node.parent.kind === 305) { + return bindParameter(node); + } + if (node.parent.kind !== 304) { + break; + } + case 322: + var propTag = node; + var flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 299 ? + 4 | 16777216 : + 4; + return declareSymbolAndAddToSymbolTable(propTag, flags, 0); + case 321: + case 314: + case 315: + return (delayedTypeAliases || (delayedTypeAliases = [])).push(node); + } + } + function bindPropertyWorker(node) { + return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 16777216 : 0), 0); + } + function bindAnonymousTypeWorker(node) { + return bindAnonymousDeclaration(node, 2048, "__type"); + } + function bindSourceFileIfExternalModule() { + setExportContextFlag(file); + if (ts.isExternalModule(file)) { + bindSourceFileAsExternalModule(); + } + else if (ts.isJsonSourceFile(file)) { + bindSourceFileAsExternalModule(); + var originalSymbol = file.symbol; + declareSymbol(file.symbol.exports, file.symbol, file, 4, 67108863); + file.symbol = originalSymbol; + } + } + function bindSourceFileAsExternalModule() { + bindAnonymousDeclaration(file, 512, "\"" + ts.removeFileExtension(file.fileName) + "\""); + } + function bindExportAssignment(node) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 2097152, getDeclarationName(node)); + } + else { + var flags = ts.exportAssignmentIsAlias(node) + ? 2097152 + : 4; + var symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863); + if (node.isExportEquals) { + setValueDeclaration(symbol, node); + } + } + } + function bindNamespaceExportDeclaration(node) { + if (node.modifiers && node.modifiers.length) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Modifiers_cannot_appear_here)); + } + var diag = !ts.isSourceFile(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_at_top_level + : !ts.isExternalModule(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_in_module_files + : !node.parent.isDeclarationFile ? ts.Diagnostics.Global_module_exports_may_only_appear_in_declaration_files + : undefined; + if (diag) { + file.bindDiagnostics.push(createDiagnosticForNode(node, diag)); + } + else { + file.symbol.globalExports = file.symbol.globalExports || ts.createSymbolTable(); + declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152, 2097152); + } + } + function bindExportDeclaration(node) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 8388608, getDeclarationName(node)); + } + else if (!node.exportClause) { + declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 0); + } + else if (ts.isNamespaceExport(node.exportClause)) { + node.exportClause.parent = node; + declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152, 2097152); + } + } + function bindImportClause(node) { + if (node.name) { + declareSymbolAndAddToSymbolTable(node, 2097152, 2097152); + } + } + function setCommonJsModuleIndicator(node) { + if (file.externalModuleIndicator) { + return false; + } + if (!file.commonJsModuleIndicator) { + file.commonJsModuleIndicator = node; + bindSourceFileAsExternalModule(); + } + return true; + } + function bindObjectDefinePropertyExport(node) { + if (!setCommonJsModuleIndicator(node)) { + return; + } + var symbol = forEachIdentifierInEntityName(node.arguments[0], undefined, function (id, symbol) { + if (symbol) { + addDeclarationToSymbol(symbol, id, 1536 | 67108864); + } + return symbol; + }); + if (symbol) { + var flags = 4 | 1048576; + declareSymbol(symbol.exports, symbol, node, flags, 0); + } + } + function bindExportsPropertyAssignment(node) { + if (!setCommonJsModuleIndicator(node)) { + return; + } + var symbol = forEachIdentifierInEntityName(node.left.expression, undefined, function (id, symbol) { + if (symbol) { + addDeclarationToSymbol(symbol, id, 1536 | 67108864); + } + return symbol; + }); + if (symbol) { + var flags = ts.isClassExpression(node.right) ? + 4 | 1048576 | 32 : + 4 | 1048576; + declareSymbol(symbol.exports, symbol, node.left, flags, 0); + } + } + function bindModuleExportsAssignment(node) { + if (!setCommonJsModuleIndicator(node)) { + return; + } + var assignedExpression = ts.getRightMostAssignedExpression(node.right); + if (ts.isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) { + return; + } + var flags = ts.exportAssignmentIsAlias(node) + ? 2097152 + : 4 | 1048576 | 512; + var symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864, 0); + setValueDeclaration(symbol, node); + } + function bindThisPropertyAssignment(node) { + ts.Debug.assert(ts.isInJSFile(node)); + var hasPrivateIdentifier = (ts.isBinaryExpression(node) && ts.isPropertyAccessExpression(node.left) && ts.isPrivateIdentifier(node.left.name)) + || (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name)); + if (hasPrivateIdentifier) { + return; + } + var thisContainer = ts.getThisContainer(node, false); + switch (thisContainer.kind) { + case 244: + case 201: + var constructorSymbol = thisContainer.symbol; + if (ts.isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 62) { + var l = thisContainer.parent.left; + if (ts.isBindableStaticAccessExpression(l) && ts.isPrototypeAccess(l.expression)) { + constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer); + } + } + if (constructorSymbol && constructorSymbol.valueDeclaration) { + constructorSymbol.members = constructorSymbol.members || ts.createSymbolTable(); + if (ts.hasDynamicName(node)) { + bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol); + } + else { + declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 | 67108864, 0 & ~4); + } + addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32); + } + break; + case 162: + case 159: + case 161: + case 163: + case 164: + var containingClass = thisContainer.parent; + var symbolTable = ts.hasModifier(thisContainer, 32) ? containingClass.symbol.exports : containingClass.symbol.members; + if (ts.hasDynamicName(node)) { + bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol); + } + else { + declareSymbol(symbolTable, containingClass.symbol, node, 4 | 67108864, 0, true); + } + break; + case 290: + if (ts.hasDynamicName(node)) { + break; + } + else if (thisContainer.commonJsModuleIndicator) { + declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 | 1048576, 0); + } + else { + declareSymbolAndAddToSymbolTable(node, 1, 111550); + } + break; + default: + ts.Debug.failBadSyntaxKind(thisContainer); + } + } + function bindDynamicallyNamedThisPropertyAssignment(node, symbol) { + bindAnonymousDeclaration(node, 4, "__computed"); + addLateBoundAssignmentDeclarationToSymbol(node, symbol); + } + function addLateBoundAssignmentDeclarationToSymbol(node, symbol) { + if (symbol) { + var members = symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = ts.createMap()); + members.set("" + ts.getNodeId(node), node); + } + } + function bindSpecialPropertyDeclaration(node) { + if (node.expression.kind === 104) { + bindThisPropertyAssignment(node); + } + else if (ts.isBindableStaticAccessExpression(node) && node.parent.parent.kind === 290) { + if (ts.isPrototypeAccess(node.expression)) { + bindPrototypePropertyAssignment(node, node.parent); + } + else { + bindStaticPropertyAssignment(node); + } + } + } + function bindPrototypeAssignment(node) { + node.left.parent = node; + node.right.parent = node; + bindPropertyAssignment(node.left.expression, node.left, false, true); + } + function bindObjectDefinePrototypeProperty(node) { + var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression); + if (namespaceSymbol && namespaceSymbol.valueDeclaration) { + addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32); + } + bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, true); + } + function bindPrototypePropertyAssignment(lhs, parent) { + var classPrototype = lhs.expression; + var constructorFunction = classPrototype.expression; + lhs.parent = parent; + constructorFunction.parent = classPrototype; + classPrototype.parent = lhs; + bindPropertyAssignment(constructorFunction, lhs, true, true); + } + function bindObjectDefinePropertyAssignment(node) { + var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]); + var isToplevel = node.parent.parent.kind === 290; + namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, false, false); + bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, false); + } + function bindSpecialPropertyAssignment(node) { + var parentSymbol = lookupSymbolForPropertyAccess(node.left.expression); + if (!ts.isInJSFile(node) && !ts.isFunctionSymbol(parentSymbol)) { + return; + } + node.left.parent = node; + node.right.parent = node; + if (ts.isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) { + bindExportsPropertyAssignment(node); + } + else { + if (ts.hasDynamicName(node)) { + bindAnonymousDeclaration(node, 4 | 67108864, "__computed"); + var sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), false, false); + addLateBoundAssignmentDeclarationToSymbol(node, sym); + } + else { + bindStaticPropertyAssignment(ts.cast(node.left, ts.isBindableStaticAccessExpression)); + } + } + } + function bindStaticPropertyAssignment(node) { + node.expression.parent = node; + bindPropertyAssignment(node.expression, node, false, false); + } + function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) { + if (isToplevel && !isPrototypeProperty) { + var flags_1 = 1536 | 67108864; + var excludeFlags_1 = 110735 & ~67108864; + namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, function (id, symbol, parent) { + if (symbol) { + addDeclarationToSymbol(symbol, id, flags_1); + return symbol; + } + else { + var table = parent ? parent.exports : + file.jsGlobalAugmentations || (file.jsGlobalAugmentations = ts.createSymbolTable()); + return declareSymbol(table, parent, id, flags_1, excludeFlags_1); + } + }); + } + if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) { + addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32); + } + return namespaceSymbol; + } + function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) { + if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) { + return; + } + var symbolTable = isPrototypeProperty ? + (namespaceSymbol.members || (namespaceSymbol.members = ts.createSymbolTable())) : + (namespaceSymbol.exports || (namespaceSymbol.exports = ts.createSymbolTable())); + var includes = 0; + var excludes = 0; + if (ts.isFunctionLikeDeclaration(ts.getAssignedExpandoInitializer(declaration))) { + includes = 8192; + excludes = 103359; + } + else if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) { + if (ts.some(declaration.arguments[2].properties, function (p) { + var id = ts.getNameOfDeclaration(p); + return !!id && ts.isIdentifier(id) && ts.idText(id) === "set"; + })) { + includes |= 65536 | 4; + excludes |= 78783; + } + if (ts.some(declaration.arguments[2].properties, function (p) { + var id = ts.getNameOfDeclaration(p); + return !!id && ts.isIdentifier(id) && ts.idText(id) === "get"; + })) { + includes |= 32768 | 4; + excludes |= 46015; + } + } + if (includes === 0) { + includes = 4; + excludes = 0; + } + declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864, excludes & ~67108864); + } + function isTopLevelNamespaceAssignment(propertyAccess) { + return ts.isBinaryExpression(propertyAccess.parent) + ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 290 + : propertyAccess.parent.parent.kind === 290; + } + function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) { + var namespaceSymbol = lookupSymbolForPropertyAccess(name); + var isToplevel = isTopLevelNamespaceAssignment(propertyAccess); + namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass); + bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty); + } + function isExpandoSymbol(symbol) { + if (symbol.flags & (16 | 32 | 1024)) { + return true; + } + var node = symbol.valueDeclaration; + if (node && ts.isCallExpression(node)) { + return !!ts.getAssignedExpandoInitializer(node); + } + var init = !node ? undefined : + ts.isVariableDeclaration(node) ? node.initializer : + ts.isBinaryExpression(node) ? node.right : + ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) ? node.parent.right : + undefined; + init = init && ts.getRightMostAssignedExpression(init); + if (init) { + var isPrototypeAssignment = ts.isPrototypeAccess(ts.isVariableDeclaration(node) ? node.name : ts.isBinaryExpression(node) ? node.left : node); + return !!ts.getExpandoInitializer(ts.isBinaryExpression(init) && (init.operatorToken.kind === 56 || init.operatorToken.kind === 60) ? init.right : init, isPrototypeAssignment); + } + return false; + } + function getParentOfBinaryExpression(expr) { + while (ts.isBinaryExpression(expr.parent)) { + expr = expr.parent; + } + return expr.parent; + } + function lookupSymbolForPropertyAccess(node, lookupContainer) { + if (lookupContainer === void 0) { lookupContainer = container; } + if (ts.isIdentifier(node)) { + return lookupSymbolForNameWorker(lookupContainer, node.escapedText); + } + else { + var symbol = lookupSymbolForPropertyAccess(node.expression); + return symbol && symbol.exports && symbol.exports.get(ts.getElementOrPropertyAccessName(node)); + } + } + function forEachIdentifierInEntityName(e, parent, action) { + if (isExportsOrModuleExportsOrAlias(file, e)) { + return file.symbol; + } + else if (ts.isIdentifier(e)) { + return action(e, lookupSymbolForPropertyAccess(e), parent); + } + else { + var s = forEachIdentifierInEntityName(e.expression, parent, action); + var name = ts.getNameOrArgument(e); + if (ts.isPrivateIdentifier(name)) { + ts.Debug.fail("unexpected PrivateIdentifier"); + } + return action(name, s && s.exports && s.exports.get(ts.getElementOrPropertyAccessName(e)), s); + } + } + function bindCallExpression(node) { + if (!file.commonJsModuleIndicator && ts.isRequireCall(node, false)) { + setCommonJsModuleIndicator(node); + } + } + function bindClassLikeDeclaration(node) { + if (node.kind === 245) { + bindBlockScopedDeclaration(node, 32, 899503); + } + else { + var bindingName = node.name ? node.name.escapedText : "__class"; + bindAnonymousDeclaration(node, 32, bindingName); + if (node.name) { + classifiableNames.set(node.name.escapedText, true); + } + } + var symbol = node.symbol; + var prototypeSymbol = createSymbol(4 | 4194304, "prototype"); + var symbolExport = symbol.exports.get(prototypeSymbol.escapedName); + if (symbolExport) { + if (node.name) { + node.name.parent = node; + } + file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(prototypeSymbol))); + } + symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol); + prototypeSymbol.parent = symbol; + } + function bindEnumDeclaration(node) { + return ts.isEnumConst(node) + ? bindBlockScopedDeclaration(node, 128, 899967) + : bindBlockScopedDeclaration(node, 256, 899327); + } + function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } + if (!ts.isBindingPattern(node.name)) { + if (ts.isBlockOrCatchScoped(node)) { + bindBlockScopedDeclaration(node, 2, 111551); + } + else if (ts.isParameterDeclaration(node)) { + declareSymbolAndAddToSymbolTable(node, 1, 111551); + } + else { + declareSymbolAndAddToSymbolTable(node, 1, 111550); + } + } + } + function bindParameter(node) { + if (node.kind === 316 && container.kind !== 305) { + return; + } + if (inStrictMode && !(node.flags & 8388608)) { + checkStrictModeEvalOrArguments(node, node.name); + } + if (ts.isBindingPattern(node.name)) { + bindAnonymousDeclaration(node, 1, "__" + node.parent.parameters.indexOf(node)); + } + else { + declareSymbolAndAddToSymbolTable(node, 1, 111551); + } + if (ts.isParameterPropertyDeclaration(node, node.parent)) { + var classDeclaration = node.parent.parent; + declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 | (node.questionToken ? 16777216 : 0), 0); + } + } + function bindFunctionDeclaration(node) { + if (!file.isDeclarationFile && !(node.flags & 8388608)) { + if (ts.isAsyncFunction(node)) { + emitFlags |= 2048; + } + } + checkStrictModeFunctionName(node); + if (inStrictMode) { + checkStrictModeFunctionDeclaration(node); + bindBlockScopedDeclaration(node, 16, 110991); + } + else { + declareSymbolAndAddToSymbolTable(node, 16, 110991); + } + } + function bindFunctionExpression(node) { + if (!file.isDeclarationFile && !(node.flags & 8388608)) { + if (ts.isAsyncFunction(node)) { + emitFlags |= 2048; + } + } + if (currentFlow) { + node.flowNode = currentFlow; + } + checkStrictModeFunctionName(node); + var bindingName = node.name ? node.name.escapedText : "__function"; + return bindAnonymousDeclaration(node, 16, bindingName); + } + function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) { + if (!file.isDeclarationFile && !(node.flags & 8388608) && ts.isAsyncFunction(node)) { + emitFlags |= 2048; + } + if (currentFlow && ts.isObjectLiteralOrClassExpressionMethod(node)) { + node.flowNode = currentFlow; + } + return ts.hasDynamicName(node) + ? bindAnonymousDeclaration(node, symbolFlags, "__computed") + : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes); + } + function getInferTypeContainer(node) { + var extendsType = ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && n.parent.extendsType === n; }); + return extendsType && extendsType.parent; + } + function bindTypeParameter(node) { + if (ts.isJSDocTemplateTag(node.parent)) { + var container_1 = ts.find(node.parent.parent.tags, ts.isJSDocTypeAlias) || ts.getHostSignatureFromJSDoc(node.parent); + if (container_1) { + if (!container_1.locals) { + container_1.locals = ts.createSymbolTable(); + } + declareSymbol(container_1.locals, undefined, node, 262144, 526824); + } + else { + declareSymbolAndAddToSymbolTable(node, 262144, 526824); + } + } + else if (node.parent.kind === 181) { + var container_2 = getInferTypeContainer(node.parent); + if (container_2) { + if (!container_2.locals) { + container_2.locals = ts.createSymbolTable(); + } + declareSymbol(container_2.locals, undefined, node, 262144, 526824); + } + else { + bindAnonymousDeclaration(node, 262144, getDeclarationName(node)); + } + } + else { + declareSymbolAndAddToSymbolTable(node, 262144, 526824); + } + } + function shouldReportErrorOnModuleDeclaration(node) { + var instanceState = getModuleInstanceState(node); + return instanceState === 1 || (instanceState === 2 && !!options.preserveConstEnums); + } + function checkUnreachable(node) { + if (!(currentFlow.flags & 1)) { + return false; + } + if (currentFlow === unreachableFlow) { + var reportError = (ts.isStatementButNotDeclaration(node) && node.kind !== 224) || + node.kind === 245 || + (node.kind === 249 && shouldReportErrorOnModuleDeclaration(node)); + if (reportError) { + currentFlow = reportedUnreachableFlow; + if (!options.allowUnreachableCode) { + var isError_1 = ts.unreachableCodeIsError(options) && + !(node.flags & 8388608) && + (!ts.isVariableStatement(node) || + !!(ts.getCombinedNodeFlags(node.declarationList) & 3) || + node.declarationList.declarations.some(function (d) { return !!d.initializer; })); + eachUnreachableRange(node, function (start, end) { return errorOrSuggestionOnRange(isError_1, start, end, ts.Diagnostics.Unreachable_code_detected); }); + } + } + } + return true; + } + } + function eachUnreachableRange(node, cb) { + if (ts.isStatement(node) && isExecutableStatement(node) && ts.isBlock(node.parent)) { + var statements = node.parent.statements; + var slice_1 = ts.sliceAfter(statements, node); + ts.getRangesWhere(slice_1, isExecutableStatement, function (start, afterEnd) { return cb(slice_1[start], slice_1[afterEnd - 1]); }); + } + else { + cb(node, node); + } + } + function isExecutableStatement(s) { + return !ts.isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !ts.isEnumDeclaration(s) && + !(ts.isVariableStatement(s) && !(ts.getCombinedNodeFlags(s) & (1 | 2)) && s.declarationList.declarations.some(function (d) { return !d.initializer; })); + } + function isPurelyTypeDeclaration(s) { + switch (s.kind) { + case 246: + case 247: + return true; + case 249: + return getModuleInstanceState(s) !== 1; + case 248: + return ts.hasModifier(s, 2048); + default: + return false; + } + } + function isExportsOrModuleExportsOrAlias(sourceFile, node) { + var i = 0; + var q = [node]; + while (q.length && i < 100) { + i++; + node = q.shift(); + if (ts.isExportsIdentifier(node) || ts.isModuleExportsAccessExpression(node)) { + return true; + } + else if (ts.isIdentifier(node)) { + var symbol = lookupSymbolForNameWorker(sourceFile, node.escapedText); + if (!!symbol && !!symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) { + var init = symbol.valueDeclaration.initializer; + q.push(init); + if (ts.isAssignmentExpression(init, true)) { + q.push(init.left); + q.push(init.right); + } + } + } + } + return false; + } + ts.isExportsOrModuleExportsOrAlias = isExportsOrModuleExportsOrAlias; + function lookupSymbolForNameWorker(container, name) { + var local = container.locals && container.locals.get(name); + if (local) { + return local.exportSymbol || local; + } + if (ts.isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) { + return container.jsGlobalAugmentations.get(name); + } + return container.symbol && container.symbol.exports && container.symbol.exports.get(name); + } + function computeTransformFlagsForNode(node, subtreeFlags) { + var kind = node.kind; + switch (kind) { + case 196: + return computeCallExpression(node, subtreeFlags); + case 197: + return computeNewExpression(node, subtreeFlags); + case 249: + return computeModuleDeclaration(node, subtreeFlags); + case 200: + return computeParenthesizedExpression(node, subtreeFlags); + case 209: + return computeBinaryExpression(node, subtreeFlags); + case 226: + return computeExpressionStatement(node, subtreeFlags); + case 156: + return computeParameter(node, subtreeFlags); + case 202: + return computeArrowFunction(node, subtreeFlags); + case 201: + return computeFunctionExpression(node, subtreeFlags); + case 244: + return computeFunctionDeclaration(node, subtreeFlags); + case 242: + return computeVariableDeclaration(node, subtreeFlags); + case 243: + return computeVariableDeclarationList(node, subtreeFlags); + case 225: + return computeVariableStatement(node, subtreeFlags); + case 238: + return computeLabeledStatement(node, subtreeFlags); + case 245: + return computeClassDeclaration(node, subtreeFlags); + case 214: + return computeClassExpression(node, subtreeFlags); + case 279: + return computeHeritageClause(node, subtreeFlags); + case 280: + return computeCatchClause(node, subtreeFlags); + case 216: + return computeExpressionWithTypeArguments(node, subtreeFlags); + case 162: + return computeConstructor(node, subtreeFlags); + case 159: + return computePropertyDeclaration(node, subtreeFlags); + case 161: + return computeMethod(node, subtreeFlags); + case 163: + case 164: + return computeAccessor(node, subtreeFlags); + case 253: + return computeImportEquals(node, subtreeFlags); + case 194: + return computePropertyAccess(node, subtreeFlags); + case 195: + return computeElementAccess(node, subtreeFlags); + default: + return computeOther(node, kind, subtreeFlags); + } + } + ts.computeTransformFlagsForNode = computeTransformFlagsForNode; + function computeCallExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags; + var callee = ts.skipOuterExpressions(node.expression); + var expression = node.expression; + if (node.flags & 32) { + transformFlags |= 8; + } + if (node.typeArguments) { + transformFlags |= 1; + } + if (subtreeFlags & 8192 || ts.isSuperOrSuperProperty(callee)) { + transformFlags |= 256; + if (ts.isSuperProperty(callee)) { + transformFlags |= 4096; + } + } + if (expression.kind === 96) { + transformFlags |= 2097152; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536879104; + } + function computeNewExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (node.typeArguments) { + transformFlags |= 1; + } + if (subtreeFlags & 8192) { + transformFlags |= 256; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536879104; + } + function computeBinaryExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags; + var operatorTokenKind = node.operatorToken.kind; + var leftKind = node.left.kind; + if (operatorTokenKind === 60) { + transformFlags |= 8; + } + else if (operatorTokenKind === 62 && leftKind === 193) { + transformFlags |= 32 | 256 | 1024; + } + else if (operatorTokenKind === 62 && leftKind === 192) { + transformFlags |= 256 | 1024; + } + else if (operatorTokenKind === 42 + || operatorTokenKind === 66) { + transformFlags |= 128; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeParameter(node, subtreeFlags) { + var transformFlags = subtreeFlags; + var name = node.name; + var initializer = node.initializer; + var dotDotDotToken = node.dotDotDotToken; + if (node.questionToken + || node.type + || (subtreeFlags & 2048 && ts.some(node.decorators)) + || ts.isThisIdentifier(name)) { + transformFlags |= 1; + } + if (ts.hasModifier(node, 92)) { + transformFlags |= 1 | 2048; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + if (subtreeFlags & 131072 || initializer || dotDotDotToken) { + transformFlags |= 256; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeParenthesizedExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags; + var expression = node.expression; + var expressionKind = expression.kind; + if (expressionKind === 217 + || expressionKind === 199) { + transformFlags |= 1; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeClassDeclaration(node, subtreeFlags) { + var transformFlags; + if (ts.hasModifier(node, 2)) { + transformFlags = 1; + } + else { + transformFlags = subtreeFlags | 256; + if ((subtreeFlags & 2048) + || node.typeParameters) { + transformFlags |= 1; + } + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536905728; + } + function computeClassExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags | 256; + if (subtreeFlags & 2048 + || node.typeParameters) { + transformFlags |= 1; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536905728; + } + function computeHeritageClause(node, subtreeFlags) { + var transformFlags = subtreeFlags; + switch (node.token) { + case 90: + transformFlags |= 256; + break; + case 113: + transformFlags |= 1; + break; + default: + ts.Debug.fail("Unexpected token for heritage clause"); + break; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeCatchClause(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (!node.variableDeclaration) { + transformFlags |= 16; + } + else if (ts.isBindingPattern(node.variableDeclaration.name)) { + transformFlags |= 256; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536887296; + } + function computeExpressionWithTypeArguments(node, subtreeFlags) { + var transformFlags = subtreeFlags | 256; + if (node.typeArguments) { + transformFlags |= 1; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeConstructor(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (ts.hasModifier(node, 2270) + || !node.body) { + transformFlags |= 1; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~538923008; + } + function computeMethod(node, subtreeFlags) { + var transformFlags = subtreeFlags | 256; + if (node.decorators + || ts.hasModifier(node, 2270) + || node.typeParameters + || node.type + || !node.body + || node.questionToken) { + transformFlags |= 1; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + if (ts.hasModifier(node, 256)) { + transformFlags |= node.asteriskToken ? 32 : 64; + } + if (node.asteriskToken) { + transformFlags |= 512; + } + node.transformFlags = transformFlags | 536870912; + return propagatePropertyNameFlags(node.name, transformFlags & ~538923008); + } + function computeAccessor(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (node.decorators + || ts.hasModifier(node, 2270) + || node.type + || !node.body) { + transformFlags |= 1; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + node.transformFlags = transformFlags | 536870912; + return propagatePropertyNameFlags(node.name, transformFlags & ~538923008); + } + function computePropertyDeclaration(node, subtreeFlags) { + var transformFlags = subtreeFlags | 4194304; + if (ts.some(node.decorators) || ts.hasModifier(node, 2270) || node.type || node.questionToken || node.exclamationToken) { + transformFlags |= 1; + } + if (ts.isComputedPropertyName(node.name) || (ts.hasStaticModifier(node) && node.initializer)) { + transformFlags |= 2048; + } + node.transformFlags = transformFlags | 536870912; + return propagatePropertyNameFlags(node.name, transformFlags & ~536875008); + } + function computeFunctionDeclaration(node, subtreeFlags) { + var transformFlags; + var modifierFlags = ts.getModifierFlags(node); + var body = node.body; + if (!body || (modifierFlags & 2)) { + transformFlags = 1; + } + else { + transformFlags = subtreeFlags | 1048576; + if (modifierFlags & 2270 + || node.typeParameters + || node.type) { + transformFlags |= 1; + } + if (modifierFlags & 256) { + transformFlags |= node.asteriskToken ? 32 : 64; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + if (node.asteriskToken) { + transformFlags |= 512; + } + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~538925056; + } + function computeFunctionExpression(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (ts.hasModifier(node, 2270) + || node.typeParameters + || node.type) { + transformFlags |= 1; + } + if (ts.hasModifier(node, 256)) { + transformFlags |= node.asteriskToken ? 32 : 64; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + if (node.asteriskToken) { + transformFlags |= 512; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~538925056; + } + function computeArrowFunction(node, subtreeFlags) { + var transformFlags = subtreeFlags | 256; + if (ts.hasModifier(node, 2270) + || node.typeParameters + || node.type) { + transformFlags |= 1; + } + if (ts.hasModifier(node, 256)) { + transformFlags |= 64; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~538920960; + } + function computePropertyAccess(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (node.flags & 32) { + transformFlags |= 8; + } + if (node.expression.kind === 102) { + transformFlags |= 64 | 32; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeElementAccess(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (node.flags & 32) { + transformFlags |= 8; + } + if (node.expression.kind === 102) { + transformFlags |= 64 | 32; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeVariableDeclaration(node, subtreeFlags) { + var transformFlags = subtreeFlags; + transformFlags |= 256 | 131072; + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + if (node.type || node.exclamationToken) { + transformFlags |= 1; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeVariableStatement(node, subtreeFlags) { + var transformFlags; + var declarationListTransformFlags = node.declarationList.transformFlags; + if (ts.hasModifier(node, 2)) { + transformFlags = 1; + } + else { + transformFlags = subtreeFlags; + if (declarationListTransformFlags & 131072) { + transformFlags |= 256; + } + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeLabeledStatement(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (subtreeFlags & 65536 + && ts.isIterationStatement(node, true)) { + transformFlags |= 256; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeImportEquals(node, subtreeFlags) { + var transformFlags = subtreeFlags; + if (!ts.isExternalModuleImportEqualsDeclaration(node)) { + transformFlags |= 1; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeExpressionStatement(node, subtreeFlags) { + var transformFlags = subtreeFlags; + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~536870912; + } + function computeModuleDeclaration(node, subtreeFlags) { + var transformFlags = 1; + var modifierFlags = ts.getModifierFlags(node); + if ((modifierFlags & 2) === 0) { + transformFlags |= subtreeFlags; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~537991168; + } + function computeVariableDeclarationList(node, subtreeFlags) { + var transformFlags = subtreeFlags | 1048576; + if (subtreeFlags & 131072) { + transformFlags |= 256; + } + if (node.flags & 3) { + transformFlags |= 256 | 65536; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~537018368; + } + function computeOther(node, kind, subtreeFlags) { + var transformFlags = subtreeFlags; + var excludeFlags = 536870912; + switch (kind) { + case 126: + transformFlags |= 32 | 64; + break; + case 206: + transformFlags |= 32 | 64 | 524288; + break; + case 199: + case 217: + case 325: + transformFlags |= 1; + excludeFlags = 536870912; + break; + case 119: + case 117: + case 118: + case 122: + case 130: + case 81: + case 248: + case 284: + case 218: + case 138: + transformFlags |= 1; + break; + case 266: + case 267: + case 268: + case 11: + case 269: + case 270: + case 271: + case 272: + case 273: + case 274: + case 275: + case 276: + transformFlags |= 2; + break; + case 14: + case 15: + case 16: + case 17: + case 211: + case 198: + case 282: + case 120: + case 219: + transformFlags |= 256; + break; + case 10: + if (node.hasExtendedUnicodeEscape) { + transformFlags |= 256; + } + break; + case 8: + if (node.numericLiteralFlags & 384) { + transformFlags |= 256; + } + break; + case 9: + transformFlags |= 4; + break; + case 232: + if (node.awaitModifier) { + transformFlags |= 32; + } + transformFlags |= 256; + break; + case 212: + transformFlags |= 32 | 256 | 262144; + break; + case 125: + case 140: + case 151: + case 137: + case 141: + case 143: + case 128: + case 144: + case 110: + case 155: + case 158: + case 160: + case 165: + case 166: + case 167: + case 168: + case 169: + case 170: + case 171: + case 172: + case 173: + case 174: + case 175: + case 176: + case 177: + case 178: + case 179: + case 180: + case 181: + case 182: + case 246: + case 247: + case 183: + case 184: + case 185: + case 186: + case 187: + case 252: + transformFlags = 1; + excludeFlags = -2; + break; + case 154: + transformFlags |= 32768; + break; + case 213: + transformFlags |= 256 | 8192; + break; + case 283: + transformFlags |= 32 | 16384; + break; + case 102: + transformFlags |= 256; + excludeFlags = 536870912; + break; + case 104: + transformFlags |= 4096; + break; + case 189: + transformFlags |= 256 | 131072; + if (subtreeFlags & 8192) { + transformFlags |= 32 | 16384; + } + excludeFlags = 536879104; + break; + case 190: + transformFlags |= 256 | 131072; + excludeFlags = 536879104; + break; + case 191: + transformFlags |= 256; + if (node.dotDotDotToken) { + transformFlags |= 8192; + } + break; + case 157: + transformFlags |= 1 | 2048; + break; + case 193: + excludeFlags = 536922112; + if (subtreeFlags & 32768) { + transformFlags |= 256; + } + if (subtreeFlags & 16384) { + transformFlags |= 32; + } + break; + case 192: + excludeFlags = 536879104; + break; + case 228: + case 229: + case 230: + case 231: + if (subtreeFlags & 65536) { + transformFlags |= 256; + } + break; + case 290: + break; + case 262: + transformFlags |= 4; + break; + case 235: + transformFlags |= 1048576 | 32; + break; + case 233: + case 234: + transformFlags |= 1048576; + break; + case 76: + transformFlags |= 4194304; + break; + } + node.transformFlags = transformFlags | 536870912; + return transformFlags & ~excludeFlags; + } + function propagatePropertyNameFlags(node, transformFlags) { + return transformFlags | (node.transformFlags & 4096); + } + function getTransformFlagsSubtreeExclusions(kind) { + if (kind >= 168 && kind <= 188) { + return -2; + } + switch (kind) { + case 196: + case 197: + case 192: + return 536879104; + case 249: + return 537991168; + case 156: + return 536870912; + case 202: + return 538920960; + case 201: + case 244: + return 538925056; + case 243: + return 537018368; + case 245: + case 214: + return 536905728; + case 162: + return 538923008; + case 161: + case 163: + case 164: + return 538923008; + case 125: + case 140: + case 151: + case 137: + case 143: + case 141: + case 128: + case 144: + case 110: + case 155: + case 158: + case 160: + case 165: + case 166: + case 167: + case 246: + case 247: + return -2; + case 193: + return 536922112; + case 280: + return 536887296; + case 189: + case 190: + return 536879104; + case 199: + case 217: + case 325: + case 200: + case 102: + return 536870912; + case 194: + case 195: + return 536870912; + default: + return 536870912; + } + } + ts.getTransformFlagsSubtreeExclusions = getTransformFlagsSubtreeExclusions; + function setParentPointers(parent, child) { + child.parent = parent; + ts.forEachChild(child, function (grandchild) { return setParentPointers(child, grandchild); }); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, getFirstIdentifier, getTypeArguments) { + return getSymbolWalker; + function getSymbolWalker(accept) { + if (accept === void 0) { accept = function () { return true; }; } + var visitedTypes = []; + var visitedSymbols = []; + return { + walkType: function (type) { + try { + visitType(type); + return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) }; + } + finally { + ts.clear(visitedTypes); + ts.clear(visitedSymbols); + } + }, + walkSymbol: function (symbol) { + try { + visitSymbol(symbol); + return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) }; + } + finally { + ts.clear(visitedTypes); + ts.clear(visitedSymbols); + } + }, + }; + function visitType(type) { + if (!type) { + return; + } + if (visitedTypes[type.id]) { + return; + } + visitedTypes[type.id] = type; + var shouldBail = visitSymbol(type.symbol); + if (shouldBail) + return; + if (type.flags & 524288) { + var objectType = type; + var objectFlags = objectType.objectFlags; + if (objectFlags & 4) { + visitTypeReference(type); + } + if (objectFlags & 32) { + visitMappedType(type); + } + if (objectFlags & (1 | 2)) { + visitInterfaceType(type); + } + if (objectFlags & (8 | 16)) { + visitObjectType(objectType); + } + } + if (type.flags & 262144) { + visitTypeParameter(type); + } + if (type.flags & 3145728) { + visitUnionOrIntersectionType(type); + } + if (type.flags & 4194304) { + visitIndexType(type); + } + if (type.flags & 8388608) { + visitIndexedAccessType(type); + } + } + function visitTypeReference(type) { + visitType(type.target); + ts.forEach(getTypeArguments(type), visitType); + } + function visitTypeParameter(type) { + visitType(getConstraintOfTypeParameter(type)); + } + function visitUnionOrIntersectionType(type) { + ts.forEach(type.types, visitType); + } + function visitIndexType(type) { + visitType(type.type); + } + function visitIndexedAccessType(type) { + visitType(type.objectType); + visitType(type.indexType); + visitType(type.constraint); + } + function visitMappedType(type) { + visitType(type.typeParameter); + visitType(type.constraintType); + visitType(type.templateType); + visitType(type.modifiersType); + } + function visitSignature(signature) { + var typePredicate = getTypePredicateOfSignature(signature); + if (typePredicate) { + visitType(typePredicate.type); + } + ts.forEach(signature.typeParameters, visitType); + for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + visitSymbol(parameter); + } + visitType(getRestTypeOfSignature(signature)); + visitType(getReturnTypeOfSignature(signature)); + } + function visitInterfaceType(interfaceT) { + visitObjectType(interfaceT); + ts.forEach(interfaceT.typeParameters, visitType); + ts.forEach(getBaseTypes(interfaceT), visitType); + visitType(interfaceT.thisType); + } + function visitObjectType(type) { + var stringIndexType = getIndexTypeOfStructuredType(type, 0); + visitType(stringIndexType); + var numberIndexType = getIndexTypeOfStructuredType(type, 1); + visitType(numberIndexType); + var resolved = resolveStructuredTypeMembers(type); + for (var _i = 0, _a = resolved.callSignatures; _i < _a.length; _i++) { + var signature = _a[_i]; + visitSignature(signature); + } + for (var _b = 0, _c = resolved.constructSignatures; _b < _c.length; _b++) { + var signature = _c[_b]; + visitSignature(signature); + } + for (var _d = 0, _e = resolved.properties; _d < _e.length; _d++) { + var p = _e[_d]; + visitSymbol(p); + } + } + function visitSymbol(symbol) { + if (!symbol) { + return false; + } + var symbolId = ts.getSymbolId(symbol); + if (visitedSymbols[symbolId]) { + return false; + } + visitedSymbols[symbolId] = symbol; + if (!accept(symbol)) { + return true; + } + var t = getTypeOfSymbol(symbol); + visitType(t); + if (symbol.exports) { + symbol.exports.forEach(visitSymbol); + } + ts.forEach(symbol.declarations, function (d) { + if (d.type && d.type.kind === 172) { + var query = d.type; + var entity = getResolvedSymbol(getFirstIdentifier(query.exprName)); + visitSymbol(entity); + } + }); + return false; + } + } + } + ts.createGetSymbolWalker = createGetSymbolWalker; +})(ts || (ts = {})); +var ts; +(function (ts) { + var ambientModuleSymbolRegex = /^".+"$/; + var anon = "(anonymous)"; + var nextSymbolId = 1; + var nextNodeId = 1; + var nextMergeId = 1; + var nextFlowId = 1; + var typeofEQFacts = ts.createMapFromTemplate({ + string: 1, + number: 2, + bigint: 4, + boolean: 8, + symbol: 16, + undefined: 65536, + object: 32, + function: 64 + }); + var typeofNEFacts = ts.createMapFromTemplate({ + string: 256, + number: 512, + bigint: 1024, + boolean: 2048, + symbol: 4096, + undefined: 524288, + object: 8192, + function: 16384 + }); + var isNotOverloadAndNotAccessor = ts.and(isNotOverload, isNotAccessor); + function getNodeId(node) { + if (!node.id) { + node.id = nextNodeId; + nextNodeId++; + } + return node.id; + } + ts.getNodeId = getNodeId; + function getSymbolId(symbol) { + if (!symbol.id) { + symbol.id = nextSymbolId; + nextSymbolId++; + } + return symbol.id; + } + ts.getSymbolId = getSymbolId; + function isInstantiatedModule(node, preserveConstEnums) { + var moduleState = ts.getModuleInstanceState(node); + return moduleState === 1 || + (preserveConstEnums && moduleState === 2); + } + ts.isInstantiatedModule = isInstantiatedModule; + function createTypeChecker(host, produceDiagnostics) { + var getPackagesSet = ts.memoize(function () { + var set = ts.createMap(); + host.getSourceFiles().forEach(function (sf) { + if (!sf.resolvedModules) + return; + ts.forEachEntry(sf.resolvedModules, function (r) { + if (r && r.packageId) + set.set(r.packageId.name, true); + }); + }); + return set; + }); + var cancellationToken; + var requestedExternalEmitHelpers; + var externalHelpersModule; + var Symbol = ts.objectAllocator.getSymbolConstructor(); + var Type = ts.objectAllocator.getTypeConstructor(); + var Signature = ts.objectAllocator.getSignatureConstructor(); + var typeCount = 0; + var symbolCount = 0; + var enumCount = 0; + var instantiationCount = 0; + var instantiationDepth = 0; + var constraintDepth = 0; + var currentNode; + var emptySymbols = ts.createSymbolTable(); + var identityMapper = ts.identity; + var arrayVariances = [1]; + var compilerOptions = host.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var allowSyntheticDefaultImports = ts.getAllowSyntheticDefaultImports(compilerOptions); + var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks"); + var strictFunctionTypes = ts.getStrictOptionValue(compilerOptions, "strictFunctionTypes"); + var strictBindCallApply = ts.getStrictOptionValue(compilerOptions, "strictBindCallApply"); + var strictPropertyInitialization = ts.getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); + var noImplicitAny = ts.getStrictOptionValue(compilerOptions, "noImplicitAny"); + var noImplicitThis = ts.getStrictOptionValue(compilerOptions, "noImplicitThis"); + var keyofStringsOnly = !!compilerOptions.keyofStringsOnly; + var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 32768; + var emitResolver = createResolver(); + var nodeBuilder = createNodeBuilder(); + var globals = ts.createSymbolTable(); + var undefinedSymbol = createSymbol(4, "undefined"); + undefinedSymbol.declarations = []; + var globalThisSymbol = createSymbol(1536, "globalThis", 8); + globalThisSymbol.exports = globals; + globalThisSymbol.declarations = []; + globals.set(globalThisSymbol.escapedName, globalThisSymbol); + var argumentsSymbol = createSymbol(4, "arguments"); + var requireSymbol = createSymbol(4, "require"); + var apparentArgumentCount; + var checker = { + getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); }, + getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); }, + getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount") + symbolCount; }, + getTypeCount: function () { return typeCount; }, + getRelationCacheSizes: function () { return ({ + assignable: assignableRelation.size, + identity: identityRelation.size, + subtype: subtypeRelation.size, + strictSubtype: strictSubtypeRelation.size, + }); }, + isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; }, + isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; }, + isUnknownSymbol: function (symbol) { return symbol === unknownSymbol; }, + getMergedSymbol: getMergedSymbol, + getDiagnostics: getDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getTypeOfSymbolAtLocation: function (symbol, location) { + location = ts.getParseTreeNode(location); + return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType; + }, + getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) { + var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter); + if (parameter === undefined) + return ts.Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node."); + return getSymbolsOfParameterPropertyDeclaration(parameter, ts.escapeLeadingUnderscores(parameterName)); + }, + getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol, + getPropertiesOfType: getPropertiesOfType, + getPropertyOfType: function (type, name) { return getPropertyOfType(type, ts.escapeLeadingUnderscores(name)); }, + getPrivateIdentifierPropertyOfType: function (leftType, name, location) { + var node = ts.getParseTreeNode(location); + if (!node) { + return undefined; + } + var propName = ts.escapeLeadingUnderscores(name); + var lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node); + return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : undefined; + }, + getTypeOfPropertyOfType: function (type, name) { return getTypeOfPropertyOfType(type, ts.escapeLeadingUnderscores(name)); }, + getIndexInfoOfType: getIndexInfoOfType, + getSignaturesOfType: getSignaturesOfType, + getIndexTypeOfType: getIndexTypeOfType, + getBaseTypes: getBaseTypes, + getBaseTypeOfLiteralType: getBaseTypeOfLiteralType, + getWidenedType: getWidenedType, + getTypeFromTypeNode: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode); + return node ? getTypeFromTypeNode(node) : errorType; + }, + getParameterType: getTypeAtPosition, + getPromisedTypeOfPromise: getPromisedTypeOfPromise, + getReturnTypeOfSignature: getReturnTypeOfSignature, + isNullableType: isNullableType, + getNullableType: getNullableType, + getNonNullableType: getNonNullableType, + getNonOptionalType: removeOptionalTypeMarker, + getTypeArguments: getTypeArguments, + typeToTypeNode: nodeBuilder.typeToTypeNode, + indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration, + signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration, + symbolToEntityName: nodeBuilder.symbolToEntityName, + symbolToExpression: nodeBuilder.symbolToExpression, + symbolToTypeParameterDeclarations: nodeBuilder.symbolToTypeParameterDeclarations, + symbolToParameterDeclaration: nodeBuilder.symbolToParameterDeclaration, + typeParameterToDeclaration: nodeBuilder.typeParameterToDeclaration, + getSymbolsInScope: function (location, meaning) { + location = ts.getParseTreeNode(location); + return location ? getSymbolsInScope(location, meaning) : []; + }, + getSymbolAtLocation: function (node) { + node = ts.getParseTreeNode(node); + return node ? getSymbolAtLocation(node) : undefined; + }, + getShorthandAssignmentValueSymbol: function (node) { + node = ts.getParseTreeNode(node); + return node ? getShorthandAssignmentValueSymbol(node) : undefined; + }, + getExportSpecifierLocalTargetSymbol: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isExportSpecifier); + return node ? getExportSpecifierLocalTargetSymbol(node) : undefined; + }, + getExportSymbolOfSymbol: function (symbol) { + return getMergedSymbol(symbol.exportSymbol || symbol); + }, + getTypeAtLocation: function (node) { + node = ts.getParseTreeNode(node); + return node ? getTypeOfNode(node) : errorType; + }, + getTypeOfAssignmentPattern: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isAssignmentPattern); + return node && getTypeOfAssignmentPattern(node) || errorType; + }, + getPropertySymbolOfDestructuringAssignment: function (locationIn) { + var location = ts.getParseTreeNode(locationIn, ts.isIdentifier); + return location ? getPropertySymbolOfDestructuringAssignment(location) : undefined; + }, + signatureToString: function (signature, enclosingDeclaration, flags, kind) { + return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind); + }, + typeToString: function (type, enclosingDeclaration, flags) { + return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags); + }, + symbolToString: function (symbol, enclosingDeclaration, meaning, flags) { + return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags); + }, + typePredicateToString: function (predicate, enclosingDeclaration, flags) { + return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags); + }, + writeSignature: function (signature, enclosingDeclaration, flags, kind, writer) { + return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind, writer); + }, + writeType: function (type, enclosingDeclaration, flags, writer) { + return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags, writer); + }, + writeSymbol: function (symbol, enclosingDeclaration, meaning, flags, writer) { + return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags, writer); + }, + writeTypePredicate: function (predicate, enclosingDeclaration, flags, writer) { + return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags, writer); + }, + getAugmentedPropertiesOfType: getAugmentedPropertiesOfType, + getRootSymbols: getRootSymbols, + getContextualType: function (nodeIn, contextFlags) { + var node = ts.getParseTreeNode(nodeIn, ts.isExpression); + if (!node) { + return undefined; + } + var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); + var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; + if (contextFlags & 4 && containingCall) { + var toMarkSkip = node; + do { + getNodeLinks(toMarkSkip).skipDirectInference = true; + toMarkSkip = toMarkSkip.parent; + } while (toMarkSkip && toMarkSkip !== containingCall); + getNodeLinks(containingCall).resolvedSignature = undefined; + } + var result = getContextualType(node, contextFlags); + if (contextFlags & 4 && containingCall) { + var toMarkSkip = node; + do { + getNodeLinks(toMarkSkip).skipDirectInference = undefined; + toMarkSkip = toMarkSkip.parent; + } while (toMarkSkip && toMarkSkip !== containingCall); + getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature; + } + return result; + }, + getContextualTypeForObjectLiteralElement: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike); + return node ? getContextualTypeForObjectLiteralElement(node) : undefined; + }, + getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) { + var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression); + return node && getContextualTypeForArgumentAtIndex(node, argIndex); + }, + getContextualTypeForJsxAttribute: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike); + return node && getContextualTypeForJsxAttribute(node); + }, + isContextSensitive: isContextSensitive, + getFullyQualifiedName: getFullyQualifiedName, + getResolvedSignature: function (node, candidatesOutArray, argumentCount) { + return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0); + }, + getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) { + return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16); + }, + getExpandedParameters: getExpandedParameters, + hasEffectiveRestParameter: hasEffectiveRestParameter, + getConstantValue: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue); + return node ? getConstantValue(node) : undefined; + }, + isValidPropertyAccess: function (nodeIn, propertyName) { + var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessOrQualifiedNameOrImportTypeNode); + return !!node && isValidPropertyAccess(node, ts.escapeLeadingUnderscores(propertyName)); + }, + isValidPropertyAccessForCompletions: function (nodeIn, type, property) { + var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessExpression); + return !!node && isValidPropertyAccessForCompletions(node, type, property); + }, + getSignatureFromDeclaration: function (declarationIn) { + var declaration = ts.getParseTreeNode(declarationIn, ts.isFunctionLike); + return declaration ? getSignatureFromDeclaration(declaration) : undefined; + }, + isImplementationOfOverload: function (node) { + var parsed = ts.getParseTreeNode(node, ts.isFunctionLike); + return parsed ? isImplementationOfOverload(parsed) : undefined; + }, + getImmediateAliasedSymbol: getImmediateAliasedSymbol, + getAliasedSymbol: resolveAlias, + getEmitResolver: getEmitResolver, + getExportsOfModule: getExportsOfModuleAsArray, + getExportsAndPropertiesOfModule: getExportsAndPropertiesOfModule, + getSymbolWalker: ts.createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, ts.getFirstIdentifier, getTypeArguments), + getAmbientModules: getAmbientModules, + getJsxIntrinsicTagNamesAt: getJsxIntrinsicTagNamesAt, + isOptionalParameter: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isParameter); + return node ? isOptionalParameter(node) : false; + }, + tryGetMemberInModuleExports: function (name, symbol) { return tryGetMemberInModuleExports(ts.escapeLeadingUnderscores(name), symbol); }, + tryGetMemberInModuleExportsAndProperties: function (name, symbol) { return tryGetMemberInModuleExportsAndProperties(ts.escapeLeadingUnderscores(name), symbol); }, + tryFindAmbientModuleWithoutAugmentations: function (moduleName) { + return tryFindAmbientModule(moduleName, false); + }, + getApparentType: getApparentType, + getUnionType: getUnionType, + isTypeAssignableTo: function (source, target) { + return isTypeAssignableTo(source, target); + }, + createAnonymousType: createAnonymousType, + createSignature: createSignature, + createSymbol: createSymbol, + createIndexInfo: createIndexInfo, + getAnyType: function () { return anyType; }, + getStringType: function () { return stringType; }, + getNumberType: function () { return numberType; }, + createPromiseType: createPromiseType, + createArrayType: createArrayType, + getElementTypeOfArrayType: getElementTypeOfArrayType, + getBooleanType: function () { return booleanType; }, + getFalseType: function (fresh) { return fresh ? falseType : regularFalseType; }, + getTrueType: function (fresh) { return fresh ? trueType : regularTrueType; }, + getVoidType: function () { return voidType; }, + getUndefinedType: function () { return undefinedType; }, + getNullType: function () { return nullType; }, + getESSymbolType: function () { return esSymbolType; }, + getNeverType: function () { return neverType; }, + getOptionalType: function () { return optionalType; }, + isSymbolAccessible: isSymbolAccessible, + isArrayType: isArrayType, + isTupleType: isTupleType, + isArrayLikeType: isArrayLikeType, + isTypeInvalidDueToUnionDiscriminant: isTypeInvalidDueToUnionDiscriminant, + getAllPossiblePropertiesOfTypes: getAllPossiblePropertiesOfTypes, + getSuggestedSymbolForNonexistentProperty: getSuggestedSymbolForNonexistentProperty, + getSuggestionForNonexistentProperty: getSuggestionForNonexistentProperty, + getSuggestedSymbolForNonexistentSymbol: function (location, name, meaning) { return getSuggestedSymbolForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); }, + getSuggestionForNonexistentSymbol: function (location, name, meaning) { return getSuggestionForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); }, + getSuggestedSymbolForNonexistentModule: getSuggestedSymbolForNonexistentModule, + getSuggestionForNonexistentExport: getSuggestionForNonexistentExport, + getBaseConstraintOfType: getBaseConstraintOfType, + getDefaultFromTypeParameter: function (type) { return type && type.flags & 262144 ? getDefaultFromTypeParameter(type) : undefined; }, + resolveName: function (name, location, meaning, excludeGlobals) { + return resolveName(location, ts.escapeLeadingUnderscores(name), meaning, undefined, undefined, false, excludeGlobals); + }, + getJsxNamespace: function (n) { return ts.unescapeLeadingUnderscores(getJsxNamespace(n)); }, + getAccessibleSymbolChain: getAccessibleSymbolChain, + getTypePredicateOfSignature: getTypePredicateOfSignature, + resolveExternalModuleSymbol: resolveExternalModuleSymbol, + tryGetThisTypeAt: function (node, includeGlobalThis) { + node = ts.getParseTreeNode(node); + return node && tryGetThisTypeAt(node, includeGlobalThis); + }, + getTypeArgumentConstraint: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode); + return node && getTypeArgumentConstraint(node); + }, + getSuggestionDiagnostics: function (file, ct) { + if (ts.skipTypeChecking(file, compilerOptions, host)) { + return ts.emptyArray; + } + var diagnostics; + try { + cancellationToken = ct; + checkSourceFile(file); + ts.Debug.assert(!!(getNodeLinks(file).flags & 1)); + diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName)); + checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) { + if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 8388608))) { + (diagnostics || (diagnostics = [])).push(__assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion })); + } + }); + return diagnostics || ts.emptyArray; + } + finally { + cancellationToken = undefined; + } + }, + runWithCancellationToken: function (token, callback) { + try { + cancellationToken = token; + return callback(checker); + } + finally { + cancellationToken = undefined; + } + }, + getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias, + isDeclarationVisible: isDeclarationVisible, + }; + function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) { + var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression); + apparentArgumentCount = argumentCount; + var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined; + apparentArgumentCount = undefined; + return res; + } + var tupleTypes = ts.createMap(); + var unionTypes = ts.createMap(); + var intersectionTypes = ts.createMap(); + var literalTypes = ts.createMap(); + var indexedAccessTypes = ts.createMap(); + var substitutionTypes = ts.createMap(); + var evolvingArrayTypes = []; + var undefinedProperties = ts.createMap(); + var unknownSymbol = createSymbol(4, "unknown"); + var resolvingSymbol = createSymbol(0, "__resolving__"); + var anyType = createIntrinsicType(1, "any"); + var autoType = createIntrinsicType(1, "any"); + var wildcardType = createIntrinsicType(1, "any"); + var errorType = createIntrinsicType(1, "error"); + var nonInferrableAnyType = createIntrinsicType(1, "any", 524288); + var unknownType = createIntrinsicType(2, "unknown"); + var undefinedType = createIntrinsicType(32768, "undefined"); + var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768, "undefined", 524288); + var optionalType = createIntrinsicType(32768, "undefined"); + var nullType = createIntrinsicType(65536, "null"); + var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536, "null", 524288); + var stringType = createIntrinsicType(4, "string"); + var numberType = createIntrinsicType(8, "number"); + var bigintType = createIntrinsicType(64, "bigint"); + var falseType = createIntrinsicType(512, "false"); + var regularFalseType = createIntrinsicType(512, "false"); + var trueType = createIntrinsicType(512, "true"); + var regularTrueType = createIntrinsicType(512, "true"); + trueType.regularType = regularTrueType; + trueType.freshType = trueType; + regularTrueType.regularType = regularTrueType; + regularTrueType.freshType = trueType; + falseType.regularType = regularFalseType; + falseType.freshType = falseType; + regularFalseType.regularType = regularFalseType; + regularFalseType.freshType = falseType; + var booleanType = createBooleanType([regularFalseType, regularTrueType]); + createBooleanType([regularFalseType, trueType]); + createBooleanType([falseType, regularTrueType]); + createBooleanType([falseType, trueType]); + var esSymbolType = createIntrinsicType(4096, "symbol"); + var voidType = createIntrinsicType(16384, "void"); + var neverType = createIntrinsicType(131072, "never"); + var silentNeverType = createIntrinsicType(131072, "never"); + var nonInferrableType = createIntrinsicType(131072, "never", 2097152); + var implicitNeverType = createIntrinsicType(131072, "never"); + var unreachableNeverType = createIntrinsicType(131072, "never"); + var nonPrimitiveType = createIntrinsicType(67108864, "object"); + var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]); + var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType; + var numberOrBigIntType = getUnionType([numberType, bigintType]); + var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + emptyJsxObjectType.objectFlags |= 4096; + var emptyTypeLiteralSymbol = createSymbol(2048, "__type"); + emptyTypeLiteralSymbol.members = ts.createSymbolTable(); + var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + emptyGenericType.instantiations = ts.createMap(); + var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + anyFunctionType.objectFlags |= 2097152; + var noConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var markerSuperType = createTypeParameter(); + var markerSubType = createTypeParameter(); + markerSubType.constraint = markerSuperType; + var markerOtherType = createTypeParameter(); + var noTypePredicate = createTypePredicate(1, "<>", 0, anyType); + var anySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0); + var unknownSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, errorType, undefined, 0, 0); + var resolvingSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0); + var silentNeverSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, silentNeverType, undefined, 0, 0); + var enumNumberIndexInfo = createIndexInfo(stringType, true); + var iterationTypesCache = ts.createMap(); + var noIterationTypes = { + get yieldType() { return ts.Debug.fail("Not supported"); }, + get returnType() { return ts.Debug.fail("Not supported"); }, + get nextType() { return ts.Debug.fail("Not supported"); }, + }; + var anyIterationTypes = createIterationTypes(anyType, anyType, anyType); + var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType); + var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); + var asyncIterationTypesResolver = { + iterableCacheKey: "iterationTypesOfAsyncIterable", + iteratorCacheKey: "iterationTypesOfAsyncIterator", + iteratorSymbolName: "asyncIterator", + getGlobalIteratorType: getGlobalAsyncIteratorType, + getGlobalIterableType: getGlobalAsyncIterableType, + getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType, + getGlobalGeneratorType: getGlobalAsyncGeneratorType, + resolveIterationType: getAwaitedType, + mustHaveANextMethodDiagnostic: ts.Diagnostics.An_async_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method, + mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property, + }; + var syncIterationTypesResolver = { + iterableCacheKey: "iterationTypesOfIterable", + iteratorCacheKey: "iterationTypesOfIterator", + iteratorSymbolName: "iterator", + getGlobalIteratorType: getGlobalIteratorType, + getGlobalIterableType: getGlobalIterableType, + getGlobalIterableIteratorType: getGlobalIterableIteratorType, + getGlobalGeneratorType: getGlobalGeneratorType, + resolveIterationType: function (type, _errorNode) { return type; }, + mustHaveANextMethodDiagnostic: ts.Diagnostics.An_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_iterator_must_be_a_method, + mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property, + }; + var amalgamatedDuplicates; + var reverseMappedCache = ts.createMap(); + var ambientModulesCache; + var patternAmbientModules; + var patternAmbientModuleAugmentations; + var globalObjectType; + var globalFunctionType; + var globalCallableFunctionType; + var globalNewableFunctionType; + var globalArrayType; + var globalReadonlyArrayType; + var globalStringType; + var globalNumberType; + var globalBooleanType; + var globalRegExpType; + var globalThisType; + var anyArrayType; + var autoArrayType; + var anyReadonlyArrayType; + var deferredGlobalNonNullableTypeAlias; + var deferredGlobalESSymbolConstructorSymbol; + var deferredGlobalESSymbolType; + var deferredGlobalTypedPropertyDescriptorType; + var deferredGlobalPromiseType; + var deferredGlobalPromiseLikeType; + var deferredGlobalPromiseConstructorSymbol; + var deferredGlobalPromiseConstructorLikeType; + var deferredGlobalIterableType; + var deferredGlobalIteratorType; + var deferredGlobalIterableIteratorType; + var deferredGlobalGeneratorType; + var deferredGlobalIteratorYieldResultType; + var deferredGlobalIteratorReturnResultType; + var deferredGlobalAsyncIterableType; + var deferredGlobalAsyncIteratorType; + var deferredGlobalAsyncIterableIteratorType; + var deferredGlobalAsyncGeneratorType; + var deferredGlobalTemplateStringsArrayType; + var deferredGlobalImportMetaType; + var deferredGlobalExtractSymbol; + var deferredGlobalOmitSymbol; + var deferredGlobalBigIntType; + var allPotentiallyUnusedIdentifiers = ts.createMap(); + var flowLoopStart = 0; + var flowLoopCount = 0; + var sharedFlowCount = 0; + var flowAnalysisDisabled = false; + var flowInvocationCount = 0; + var lastFlowNode; + var lastFlowNodeReachable; + var flowTypeCache; + var emptyStringType = getLiteralType(""); + var zeroType = getLiteralType(0); + var zeroBigIntType = getLiteralType({ negative: false, base10Value: "0" }); + var resolutionTargets = []; + var resolutionResults = []; + var resolutionPropertyNames = []; + var suggestionCount = 0; + var maximumSuggestionCount = 10; + var mergedSymbols = []; + var symbolLinks = []; + var nodeLinks = []; + var flowLoopCaches = []; + var flowLoopNodes = []; + var flowLoopKeys = []; + var flowLoopTypes = []; + var sharedFlowNodes = []; + var sharedFlowTypes = []; + var flowNodeReachable = []; + var potentialThisCollisions = []; + var potentialNewTargetCollisions = []; + var potentialWeakMapCollisions = []; + var awaitedTypeStack = []; + var diagnostics = ts.createDiagnosticCollection(); + var suggestionDiagnostics = ts.createDiagnosticCollection(); + var typeofTypesByName = ts.createMapFromTemplate({ + string: stringType, + number: numberType, + bigint: bigintType, + boolean: booleanType, + symbol: esSymbolType, + undefined: undefinedType + }); + var typeofType = createTypeofType(); + var _jsxNamespace; + var _jsxFactoryEntity; + var outofbandVarianceMarkerHandler; + var subtypeRelation = ts.createMap(); + var strictSubtypeRelation = ts.createMap(); + var assignableRelation = ts.createMap(); + var comparableRelation = ts.createMap(); + var identityRelation = ts.createMap(); + var enumRelation = ts.createMap(); + var builtinGlobals = ts.createSymbolTable(); + builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol); + initializeTypeChecker(); + return checker; + function getJsxNamespace(location) { + if (location) { + var file = ts.getSourceFileOfNode(location); + if (file) { + if (file.localJsxNamespace) { + return file.localJsxNamespace; + } + var jsxPragma = file.pragmas.get("jsx"); + if (jsxPragma) { + var chosenpragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma; + file.localJsxFactory = ts.parseIsolatedEntityName(chosenpragma.arguments.factory, languageVersion); + if (file.localJsxFactory) { + return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText; + } + } + } + } + if (!_jsxNamespace) { + _jsxNamespace = "React"; + if (compilerOptions.jsxFactory) { + _jsxFactoryEntity = ts.parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion); + if (_jsxFactoryEntity) { + _jsxNamespace = ts.getFirstIdentifier(_jsxFactoryEntity).escapedText; + } + } + else if (compilerOptions.reactNamespace) { + _jsxNamespace = ts.escapeLeadingUnderscores(compilerOptions.reactNamespace); + } + } + return _jsxNamespace; + } + function getEmitResolver(sourceFile, cancellationToken) { + getDiagnostics(sourceFile, cancellationToken); + return emitResolver; + } + function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) { + var diagnostic = location + ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) + : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3); + var existing = diagnostics.lookup(diagnostic); + if (existing) { + return existing; + } + else { + diagnostics.add(diagnostic); + return diagnostic; + } + } + function error(location, message, arg0, arg1, arg2, arg3) { + var diagnostic = location + ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) + : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3); + diagnostics.add(diagnostic); + return diagnostic; + } + function addErrorOrSuggestion(isError, diagnostic) { + if (isError) { + diagnostics.add(diagnostic); + } + else { + suggestionDiagnostics.add(__assign(__assign({}, diagnostic), { category: ts.DiagnosticCategory.Suggestion })); + } + } + function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) { + addErrorOrSuggestion(isError, "message" in message ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForNodeFromMessageChain(location, message)); + } + function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) { + var diagnostic = error(location, message, arg0, arg1, arg2, arg3); + if (maybeMissingAwait) { + var related = ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_forget_to_use_await); + ts.addRelatedInfo(diagnostic, related); + } + return diagnostic; + } + function createSymbol(flags, name, checkFlags) { + symbolCount++; + var symbol = (new Symbol(flags | 33554432, name)); + symbol.checkFlags = checkFlags || 0; + return symbol; + } + function getExcludedSymbolFlags(flags) { + var result = 0; + if (flags & 2) + result |= 111551; + if (flags & 1) + result |= 111550; + if (flags & 4) + result |= 0; + if (flags & 8) + result |= 900095; + if (flags & 16) + result |= 110991; + if (flags & 32) + result |= 899503; + if (flags & 64) + result |= 788872; + if (flags & 256) + result |= 899327; + if (flags & 128) + result |= 899967; + if (flags & 512) + result |= 110735; + if (flags & 8192) + result |= 103359; + if (flags & 32768) + result |= 46015; + if (flags & 65536) + result |= 78783; + if (flags & 262144) + result |= 526824; + if (flags & 524288) + result |= 788968; + if (flags & 2097152) + result |= 2097152; + return result; + } + function recordMergedSymbol(target, source) { + if (!source.mergeId) { + source.mergeId = nextMergeId; + nextMergeId++; + } + mergedSymbols[source.mergeId] = target; + } + function cloneSymbol(symbol) { + var result = createSymbol(symbol.flags, symbol.escapedName); + result.declarations = symbol.declarations ? symbol.declarations.slice() : []; + result.parent = symbol.parent; + if (symbol.valueDeclaration) + result.valueDeclaration = symbol.valueDeclaration; + if (symbol.constEnumOnlyModule) + result.constEnumOnlyModule = true; + if (symbol.members) + result.members = ts.cloneMap(symbol.members); + if (symbol.exports) + result.exports = ts.cloneMap(symbol.exports); + recordMergedSymbol(result, symbol); + return result; + } + function mergeSymbol(target, source, unidirectional) { + if (unidirectional === void 0) { unidirectional = false; } + if (!(target.flags & getExcludedSymbolFlags(source.flags)) || + (source.flags | target.flags) & 67108864) { + if (source === target) { + return target; + } + if (!(target.flags & 33554432)) { + var resolvedTarget = resolveSymbol(target); + if (resolvedTarget === unknownSymbol) { + return source; + } + target = cloneSymbol(resolvedTarget); + } + if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { + target.constEnumOnlyModule = false; + } + target.flags |= source.flags; + if (source.valueDeclaration && + (!target.valueDeclaration || + ts.isAssignmentDeclaration(target.valueDeclaration) && !ts.isAssignmentDeclaration(source.valueDeclaration) || + ts.isEffectiveModuleDeclaration(target.valueDeclaration) && !ts.isEffectiveModuleDeclaration(source.valueDeclaration))) { + target.valueDeclaration = source.valueDeclaration; + } + ts.addRange(target.declarations, source.declarations); + if (source.members) { + if (!target.members) + target.members = ts.createSymbolTable(); + mergeSymbolTable(target.members, source.members, unidirectional); + } + if (source.exports) { + if (!target.exports) + target.exports = ts.createSymbolTable(); + mergeSymbolTable(target.exports, source.exports, unidirectional); + } + if (!unidirectional) { + recordMergedSymbol(target, source); + } + } + else if (target.flags & 1024) { + if (target !== globalThisSymbol) { + error(ts.getNameOfDeclaration(source.declarations[0]), ts.Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target)); + } + } + else { + var isEitherEnum = !!(target.flags & 384 || source.flags & 384); + var isEitherBlockScoped_1 = !!(target.flags & 2 || source.flags & 2); + var message = isEitherEnum + ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations + : isEitherBlockScoped_1 + ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 + : ts.Diagnostics.Duplicate_identifier_0; + var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]); + var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]); + var symbolName_1 = symbolToString(source); + if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) { + var firstFile_1 = ts.comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 ? sourceSymbolFile : targetSymbolFile; + var secondFile_1 = firstFile_1 === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile; + var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, firstFile_1.path + "|" + secondFile_1.path, function () { + return ({ firstFile: firstFile_1, secondFile: secondFile_1, conflictingSymbols: ts.createMap() }); + }); + var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () { + return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] }); + }); + addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source); + addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target); + } + else { + addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target); + addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source); + } + } + return target; + function addDuplicateLocations(locs, symbol) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + ts.pushIfUnique(locs, (ts.getExpandoInitializer(decl, false) ? ts.getNameOfExpando(decl) : ts.getNameOfDeclaration(decl)) || decl); + } + } + } + function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName, source) { + ts.forEach(target.declarations, function (node) { + var errorNode = (ts.getExpandoInitializer(node, false) ? ts.getNameOfExpando(node) : ts.getNameOfDeclaration(node)) || node; + addDuplicateDeclarationError(errorNode, message, symbolName, source.declarations); + }); + } + function addDuplicateDeclarationError(errorNode, message, symbolName, relatedNodes) { + var err = lookupOrIssueError(errorNode, message, symbolName); + for (var _i = 0, _a = relatedNodes || ts.emptyArray; _i < _a.length; _i++) { + var relatedNode = _a[_i]; + err.relatedInformation = err.relatedInformation || []; + if (ts.length(err.relatedInformation) >= 5) + continue; + ts.addRelatedInfo(err, !ts.length(err.relatedInformation) ? ts.createDiagnosticForNode(relatedNode, ts.Diagnostics._0_was_also_declared_here, symbolName) : ts.createDiagnosticForNode(relatedNode, ts.Diagnostics.and_here)); + } + } + function combineSymbolTables(first, second) { + if (!ts.hasEntries(first)) + return second; + if (!ts.hasEntries(second)) + return first; + var combined = ts.createSymbolTable(); + mergeSymbolTable(combined, first); + mergeSymbolTable(combined, second); + return combined; + } + function mergeSymbolTable(target, source, unidirectional) { + if (unidirectional === void 0) { unidirectional = false; } + source.forEach(function (sourceSymbol, id) { + var targetSymbol = target.get(id); + target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : sourceSymbol); + }); + } + function mergeModuleAugmentation(moduleName) { + var moduleAugmentation = moduleName.parent; + if (moduleAugmentation.symbol.declarations[0] !== moduleAugmentation) { + ts.Debug.assert(moduleAugmentation.symbol.declarations.length > 1); + return; + } + if (ts.isGlobalScopeAugmentation(moduleAugmentation)) { + mergeSymbolTable(globals, moduleAugmentation.symbol.exports); + } + else { + var moduleNotFoundError = !(moduleName.parent.parent.flags & 8388608) + ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found + : undefined; + var mainModule_1 = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, true); + if (!mainModule_1) { + return; + } + mainModule_1 = resolveExternalModuleSymbol(mainModule_1); + if (mainModule_1.flags & 1920) { + if (ts.some(patternAmbientModules, function (module) { return mainModule_1 === module.symbol; })) { + var merged = mergeSymbol(moduleAugmentation.symbol, mainModule_1, true); + if (!patternAmbientModuleAugmentations) { + patternAmbientModuleAugmentations = ts.createMap(); + } + patternAmbientModuleAugmentations.set(moduleName.text, merged); + } + else { + mergeSymbol(mainModule_1, moduleAugmentation.symbol); + } + } + else { + error(moduleName, ts.Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text); + } + } + } + function addToSymbolTable(target, source, message) { + source.forEach(function (sourceSymbol, id) { + var targetSymbol = target.get(id); + if (targetSymbol) { + ts.forEach(targetSymbol.declarations, addDeclarationDiagnostic(ts.unescapeLeadingUnderscores(id), message)); + } + else { + target.set(id, sourceSymbol); + } + }); + function addDeclarationDiagnostic(id, message) { + return function (declaration) { return diagnostics.add(ts.createDiagnosticForNode(declaration, message, id)); }; + } + } + function getSymbolLinks(symbol) { + if (symbol.flags & 33554432) + return symbol; + var id = getSymbolId(symbol); + return symbolLinks[id] || (symbolLinks[id] = {}); + } + function getNodeLinks(node) { + var nodeId = getNodeId(node); + return nodeLinks[nodeId] || (nodeLinks[nodeId] = { flags: 0 }); + } + function isGlobalSourceFile(node) { + return node.kind === 290 && !ts.isExternalOrCommonJsModule(node); + } + function getSymbol(symbols, name, meaning) { + if (meaning) { + var symbol = symbols.get(name); + if (symbol) { + ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here."); + if (symbol.flags & meaning) { + return symbol; + } + if (symbol.flags & 2097152) { + var target = resolveAlias(symbol); + if (target === unknownSymbol || target.flags & meaning) { + return symbol; + } + } + } + } + } + function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) { + var constructorDeclaration = parameter.parent; + var classDeclaration = parameter.parent.parent; + var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 111551); + var propertySymbol = getSymbol(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551); + if (parameterSymbol && propertySymbol) { + return [parameterSymbol, propertySymbol]; + } + return ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration"); + } + function isBlockScopedNameDeclaredBeforeUse(declaration, usage) { + var declarationFile = ts.getSourceFileOfNode(declaration); + var useFile = ts.getSourceFileOfNode(usage); + if (declarationFile !== useFile) { + if ((moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) || + (!compilerOptions.outFile && !compilerOptions.out) || + isInTypeQuery(usage) || + declaration.flags & 8388608) { + return true; + } + if (isUsedInFunctionOrInstanceProperty(usage, declaration)) { + return true; + } + var sourceFiles = host.getSourceFiles(); + return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile); + } + if (declaration.pos <= usage.pos) { + if (declaration.kind === 191) { + var errorBindingElement = ts.getAncestor(usage, 191); + if (errorBindingElement) { + return ts.findAncestor(errorBindingElement, ts.isBindingElement) !== ts.findAncestor(declaration, ts.isBindingElement) || + declaration.pos < errorBindingElement.pos; + } + return isBlockScopedNameDeclaredBeforeUse(ts.getAncestor(declaration, 242), usage); + } + else if (declaration.kind === 242) { + return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage); + } + else if (ts.isClassDeclaration(declaration)) { + return !ts.findAncestor(usage, function (n) { return ts.isComputedPropertyName(n) && n.parent.parent === declaration; }); + } + else if (ts.isPropertyDeclaration(declaration)) { + return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false); + } + else if (ts.isParameterPropertyDeclaration(declaration, declaration.parent)) { + var container_3 = ts.getEnclosingBlockScopeContainer(declaration.parent); + return !(compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields + && ts.getContainingClass(declaration) === ts.getContainingClass(usage) + && isUsedInFunctionOrInstanceProperty(usage, declaration, container_3)); + } + return true; + } + if (usage.parent.kind === 263 || (usage.parent.kind === 259 && usage.parent.isExportEquals)) { + return true; + } + if (usage.kind === 259 && usage.isExportEquals) { + return true; + } + var container = ts.getEnclosingBlockScopeContainer(declaration); + if (!!(usage.flags & 4194304) || isInTypeQuery(usage)) { + return true; + } + if (isUsedInFunctionOrInstanceProperty(usage, declaration, container)) { + if (compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields) { + return (ts.isPropertyDeclaration(declaration) || ts.isParameterPropertyDeclaration(declaration, declaration.parent)) && + !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true); + } + else { + return true; + } + } + return false; + function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage) { + var container = ts.getEnclosingBlockScopeContainer(declaration); + switch (declaration.parent.parent.kind) { + case 225: + case 230: + case 232: + if (isSameScopeDescendentOf(usage, declaration, container)) { + return true; + } + break; + } + var grandparent = declaration.parent.parent; + return ts.isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage, grandparent.expression, container); + } + function isUsedInFunctionOrInstanceProperty(usage, declaration, container) { + return !!ts.findAncestor(usage, function (current) { + if (current === container) { + return "quit"; + } + if (ts.isFunctionLike(current)) { + return true; + } + var initializerOfProperty = current.parent && + current.parent.kind === 159 && + current.parent.initializer === current; + if (initializerOfProperty) { + if (ts.hasModifier(current.parent, 32)) { + if (declaration.kind === 161) { + return true; + } + } + else { + var isDeclarationInstanceProperty = declaration.kind === 159 && !ts.hasModifier(declaration, 32); + if (!isDeclarationInstanceProperty || ts.getContainingClass(usage) !== ts.getContainingClass(declaration)) { + return true; + } + } + } + return false; + }); + } + function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, stopAtAnyPropertyDeclaration) { + if (usage.end > declaration.end) { + return false; + } + var ancestorChangingReferenceScope = ts.findAncestor(usage, function (node) { + if (node === declaration) { + return "quit"; + } + switch (node.kind) { + case 202: + return true; + case 159: + return stopAtAnyPropertyDeclaration && + (ts.isPropertyDeclaration(declaration) && node.parent === declaration.parent + || ts.isParameterPropertyDeclaration(declaration, declaration.parent) && node.parent === declaration.parent.parent) + ? "quit" : true; + case 223: + switch (node.parent.kind) { + case 163: + case 161: + case 164: + return true; + default: + return false; + } + default: + return false; + } + }); + return ancestorChangingReferenceScope === undefined; + } + } + function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, suggestedNameNotFoundMessage) { + if (excludeGlobals === void 0) { excludeGlobals = false; } + return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSymbol, suggestedNameNotFoundMessage); + } + function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, lookup, suggestedNameNotFoundMessage) { + var originalLocation = location; + var result; + var lastLocation; + var lastSelfReferenceLocation; + var propertyWithInvalidInitializer; + var associatedDeclarationForContainingInitializer; + var withinDeferredContext = false; + var errorLocation = location; + var grandparent; + var isInExternalModule = false; + loop: while (location) { + if (location.locals && !isGlobalSourceFile(location)) { + if (result = lookup(location.locals, name, meaning)) { + var useResult = true; + if (ts.isFunctionLike(location) && lastLocation && lastLocation !== location.body) { + if (meaning & result.flags & 788968 && lastLocation.kind !== 303) { + useResult = result.flags & 262144 + ? lastLocation === location.type || + lastLocation.kind === 156 || + lastLocation.kind === 155 + : false; + } + if (meaning & result.flags & 3) { + var functionLocation = location; + if (compilerOptions.target && compilerOptions.target >= 2 && ts.isParameter(lastLocation) && + functionLocation.body && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) { + useResult = false; + } + else if (result.flags & 1) { + useResult = + lastLocation.kind === 156 || + (lastLocation === location.type && + !!ts.findAncestor(result.valueDeclaration, ts.isParameter)); + } + } + } + else if (location.kind === 180) { + useResult = lastLocation === location.trueType; + } + if (useResult) { + break loop; + } + else { + result = undefined; + } + } + } + withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation); + switch (location.kind) { + case 290: + if (!ts.isExternalOrCommonJsModule(location)) + break; + isInExternalModule = true; + case 249: + var moduleExports = getSymbolOfNode(location).exports || emptySymbols; + if (location.kind === 290 || (ts.isModuleDeclaration(location) && location.flags & 8388608 && !ts.isGlobalScopeAugmentation(location))) { + if (result = moduleExports.get("default")) { + var localSymbol = ts.getLocalSymbolForExportDefault(result); + if (localSymbol && (result.flags & meaning) && localSymbol.escapedName === name) { + break loop; + } + result = undefined; + } + var moduleExport = moduleExports.get(name); + if (moduleExport && + moduleExport.flags === 2097152 && + (ts.getDeclarationOfKind(moduleExport, 263) || ts.getDeclarationOfKind(moduleExport, 262))) { + break; + } + } + if (name !== "default" && (result = lookup(moduleExports, name, meaning & 2623475))) { + if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !result.declarations.some(ts.isJSDocTypeAlias)) { + result = undefined; + } + else { + break loop; + } + } + break; + case 248: + if (result = lookup(getSymbolOfNode(location).exports, name, meaning & 8)) { + break loop; + } + break; + case 159: + if (!ts.hasModifier(location, 32)) { + var ctor = findConstructorDeclaration(location.parent); + if (ctor && ctor.locals) { + if (lookup(ctor.locals, name, meaning & 111551)) { + propertyWithInvalidInitializer = location; + } + } + } + break; + case 245: + case 214: + case 246: + if (result = lookup(getSymbolOfNode(location).members || emptySymbols, name, meaning & 788968)) { + if (!isTypeParameterSymbolDeclaredInContainer(result, location)) { + result = undefined; + break; + } + if (lastLocation && ts.hasModifier(lastLocation, 32)) { + error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters); + return undefined; + } + break loop; + } + if (location.kind === 214 && meaning & 32) { + var className = location.name; + if (className && name === className.escapedText) { + result = location.symbol; + break loop; + } + } + break; + case 216: + if (lastLocation === location.expression && location.parent.token === 90) { + var container = location.parent.parent; + if (ts.isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968))) { + if (nameNotFoundMessage) { + error(errorLocation, ts.Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters); + } + return undefined; + } + } + break; + case 154: + grandparent = location.parent.parent; + if (ts.isClassLike(grandparent) || grandparent.kind === 246) { + if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968)) { + error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); + return undefined; + } + } + break; + case 202: + if (compilerOptions.target >= 2) { + break; + } + case 161: + case 162: + case 163: + case 164: + case 244: + if (meaning & 3 && name === "arguments") { + result = argumentsSymbol; + break loop; + } + break; + case 201: + if (meaning & 3 && name === "arguments") { + result = argumentsSymbol; + break loop; + } + if (meaning & 16) { + var functionName = location.name; + if (functionName && name === functionName.escapedText) { + result = location.symbol; + break loop; + } + } + break; + case 157: + if (location.parent && location.parent.kind === 156) { + location = location.parent; + } + if (location.parent && (ts.isClassElement(location.parent) || location.parent.kind === 245)) { + location = location.parent; + } + break; + case 321: + case 314: + case 315: + location = ts.getJSDocHost(location); + break; + case 156: + if (lastLocation && lastLocation === location.initializer) { + associatedDeclarationForContainingInitializer = location; + } + break; + case 191: + if (lastLocation && lastLocation === location.initializer) { + var root = ts.getRootDeclaration(location); + if (root.kind === 156) { + associatedDeclarationForContainingInitializer = location; + } + } + break; + } + if (isSelfReferenceLocation(location)) { + lastSelfReferenceLocation = location; + } + lastLocation = location; + location = location.parent; + } + if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) { + result.isReferenced |= meaning; + } + if (!result) { + if (lastLocation) { + ts.Debug.assert(lastLocation.kind === 290); + if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) { + return lastLocation.symbol; + } + } + if (!excludeGlobals) { + result = lookup(globals, name, meaning); + } + } + if (!result) { + if (originalLocation && ts.isInJSFile(originalLocation) && originalLocation.parent) { + if (ts.isRequireCall(originalLocation.parent, false)) { + return requireSymbol; + } + } + } + if (!result) { + if (nameNotFoundMessage) { + if (!errorLocation || + !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && + !checkAndReportErrorForExtendingInterface(errorLocation) && + !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && + !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && + !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && + !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) && + !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) { + var suggestion = void 0; + if (suggestedNameNotFoundMessage && suggestionCount < maximumSuggestionCount) { + suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning); + if (suggestion) { + var suggestionName = symbolToString(suggestion); + var diagnostic = error(errorLocation, suggestedNameNotFoundMessage, diagnosticName(nameArg), suggestionName); + if (suggestion.valueDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName)); + } + } + } + if (!suggestion) { + error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg)); + } + suggestionCount++; + } + } + return undefined; + } + if (nameNotFoundMessage) { + if (propertyWithInvalidInitializer && !(compilerOptions.target === 99 && compilerOptions.useDefineForClassFields)) { + var propertyName = propertyWithInvalidInitializer.name; + error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg)); + return undefined; + } + if (errorLocation && + (meaning & 2 || + ((meaning & 32 || meaning & 384) && (meaning & 111551) === 111551))) { + var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result); + if (exportOrLocalSymbol.flags & 2 || exportOrLocalSymbol.flags & 32 || exportOrLocalSymbol.flags & 384) { + checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation); + } + } + if (result && isInExternalModule && (meaning & 111551) === 111551 && !(originalLocation.flags & 4194304)) { + var merged = getMergedSymbol(result); + if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) { + errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name)); + } + } + if (result && associatedDeclarationForContainingInitializer && !withinDeferredContext && (meaning & 111551) === 111551) { + var candidate = getMergedSymbol(getLateBoundSymbol(result)); + var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializer); + if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializer)) { + error(errorLocation, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(associatedDeclarationForContainingInitializer.name)); + } + else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializer.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) { + error(errorLocation, ts.Diagnostics.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializer.name), ts.declarationNameToString(errorLocation)); + } + } + if (result && errorLocation && meaning & 111551 && result.flags & 2097152) { + checkSymbolUsageInExpressionContext(result, name, errorLocation); + } + } + return result; + } + function checkSymbolUsageInExpressionContext(symbol, name, useSite) { + if (!ts.isValidTypeOnlyAliasUseSite(useSite)) { + var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol); + if (typeOnlyDeclaration) { + var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration); + var message = isExport + ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type + : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type; + var relatedMessage = isExport + ? ts.Diagnostics._0_was_exported_here + : ts.Diagnostics._0_was_imported_here; + var unescapedName = ts.unescapeLeadingUnderscores(name); + ts.addRelatedInfo(error(useSite, message, unescapedName), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, unescapedName)); + } + } + } + function getIsDeferredContext(location, lastLocation) { + if (location.kind !== 202 && location.kind !== 201) { + return ts.isTypeQueryNode(location) || ((ts.isFunctionLikeDeclaration(location) || + (location.kind === 159 && !ts.hasModifier(location, 32))) && (!lastLocation || lastLocation !== location.name)); + } + if (lastLocation && lastLocation === location.name) { + return false; + } + if (location.asteriskToken || ts.hasModifier(location, 256)) { + return true; + } + return !ts.getImmediatelyInvokedFunctionExpression(location); + } + function isSelfReferenceLocation(node) { + switch (node.kind) { + case 244: + case 245: + case 246: + case 248: + case 247: + case 249: + return true; + default: + return false; + } + } + function diagnosticName(nameArg) { + return ts.isString(nameArg) ? ts.unescapeLeadingUnderscores(nameArg) : ts.declarationNameToString(nameArg); + } + function isTypeParameterSymbolDeclaredInContainer(symbol, container) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.kind === 155) { + var parent = ts.isJSDocTemplateTag(decl.parent) ? ts.getJSDocHost(decl.parent) : decl.parent; + if (parent === container) { + return !(ts.isJSDocTemplateTag(decl.parent) && ts.find(decl.parent.parent.tags, ts.isJSDocTypeAlias)); + } + } + } + return false; + } + function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) { + if (!ts.isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) { + return false; + } + var container = ts.getThisContainer(errorLocation, false); + var location = container; + while (location) { + if (ts.isClassLike(location.parent)) { + var classSymbol = getSymbolOfNode(location.parent); + if (!classSymbol) { + break; + } + var constructorType = getTypeOfSymbol(classSymbol); + if (getPropertyOfType(constructorType, name)) { + error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol)); + return true; + } + if (location === container && !ts.hasModifier(location, 32)) { + var instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType; + if (getPropertyOfType(instanceType, name)) { + error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, diagnosticName(nameArg)); + return true; + } + } + } + location = location.parent; + } + return false; + } + function checkAndReportErrorForExtendingInterface(errorLocation) { + var expression = getEntityNameForExtendingInterface(errorLocation); + if (expression && resolveEntityName(expression, 64, true)) { + error(errorLocation, ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, ts.getTextOfNode(expression)); + return true; + } + return false; + } + function getEntityNameForExtendingInterface(node) { + switch (node.kind) { + case 75: + case 194: + return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined; + case 216: + if (ts.isEntityNameExpression(node.expression)) { + return node.expression; + } + default: + return undefined; + } + } + function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) { + var namespaceMeaning = 1920 | (ts.isInJSFile(errorLocation) ? 111551 : 0); + if (meaning === namespaceMeaning) { + var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~namespaceMeaning, undefined, undefined, false)); + var parent = errorLocation.parent; + if (symbol) { + if (ts.isQualifiedName(parent)) { + ts.Debug.assert(parent.left === errorLocation, "Should only be resolving left side of qualified name as a namespace"); + var propName = parent.right.escapedText; + var propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName); + if (propType) { + error(parent, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, ts.unescapeLeadingUnderscores(name), ts.unescapeLeadingUnderscores(propName)); + return true; + } + } + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) { + if (meaning & (788968 & ~1920)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 & 111551, undefined, undefined, false)); + if (symbol && !(symbol.flags & 1920)) { + error(errorLocation, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function isPrimitiveTypeName(name) { + return name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never" || name === "unknown"; + } + function checkAndReportErrorForExportingPrimitiveType(errorLocation, name) { + if (isPrimitiveTypeName(name) && errorLocation.parent.kind === 263) { + error(errorLocation, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, name); + return true; + } + return false; + } + function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) { + if (meaning & (111551 & ~1024)) { + if (isPrimitiveTypeName(name)) { + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name)); + return true; + } + var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~111551, undefined, undefined, false)); + if (symbol && !(symbol.flags & 1024)) { + var message = isES2015OrLaterConstructorName(name) + ? ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later + : ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here; + error(errorLocation, message, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function isES2015OrLaterConstructorName(n) { + switch (n) { + case "Promise": + case "Symbol": + case "Map": + case "WeakMap": + case "Set": + case "WeakSet": + return true; + } + return false; + } + function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) { + if (meaning & (111551 & ~1024 & ~788968)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 & ~111551, undefined, undefined, false)); + if (symbol) { + error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + else if (meaning & (788968 & ~1024 & ~111551)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, (512 | 1024) & ~788968, undefined, undefined, false)); + if (symbol) { + error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function checkResolvedBlockScopedVariable(result, errorLocation) { + ts.Debug.assert(!!(result.flags & 2 || result.flags & 32 || result.flags & 384)); + if (result.flags & (16 | 1 | 67108864) && result.flags & 32) { + return; + } + var declaration = ts.find(result.declarations, function (d) { return ts.isBlockOrCatchScoped(d) || ts.isClassLike(d) || (d.kind === 248); }); + if (declaration === undefined) + return ts.Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration"); + if (!(declaration.flags & 8388608) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) { + var diagnosticMessage = void 0; + var declarationName = ts.declarationNameToString(ts.getNameOfDeclaration(declaration)); + if (result.flags & 2) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName); + } + else if (result.flags & 32) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName); + } + else if (result.flags & 256) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName); + } + else { + ts.Debug.assert(!!(result.flags & 128)); + if (compilerOptions.preserveConstEnums) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName); + } + } + if (diagnosticMessage) { + ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_is_declared_here, declarationName)); + } + } + } + function isSameScopeDescendentOf(initial, parent, stopAt) { + return !!parent && !!ts.findAncestor(initial, function (n) { return n === stopAt || ts.isFunctionLike(n) ? "quit" : n === parent; }); + } + function getAnyImportSyntax(node) { + switch (node.kind) { + case 253: + return node; + case 255: + return node.parent; + case 256: + return node.parent.parent; + case 258: + return node.parent.parent.parent; + default: + return undefined; + } + } + function getDeclarationOfAliasSymbol(symbol) { + return ts.find(symbol.declarations, isAliasSymbolDeclaration); + } + function isAliasSymbolDeclaration(node) { + return node.kind === 253 || + node.kind === 252 || + node.kind === 255 && !!node.name || + node.kind === 256 || + node.kind === 262 || + node.kind === 258 || + node.kind === 263 || + node.kind === 259 && ts.exportAssignmentIsAlias(node) || + ts.isBinaryExpression(node) && ts.getAssignmentDeclarationKind(node) === 2 && ts.exportAssignmentIsAlias(node) || + ts.isPropertyAccessExpression(node) + && ts.isBinaryExpression(node.parent) + && node.parent.left === node + && node.parent.operatorToken.kind === 62 + && isAliasableOrJsExpression(node.parent.right) || + node.kind === 282 || + node.kind === 281 && isAliasableOrJsExpression(node.initializer); + } + function isAliasableOrJsExpression(e) { + return ts.isAliasableExpression(e) || ts.isFunctionExpression(e) && isJSConstructor(e); + } + function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) { + if (node.moduleReference.kind === 265) { + var immediate = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var resolved_4 = resolveExternalModuleSymbol(immediate); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved_4, false); + return resolved_4; + } + var resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias); + checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved); + return resolved; + } + function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) { + if (markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false)) { + var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node)); + var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration); + var message = isExport + ? ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type + : ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type; + var relatedMessage = isExport + ? ts.Diagnostics._0_was_exported_here + : ts.Diagnostics._0_was_imported_here; + var name = ts.unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText); + ts.addRelatedInfo(error(node.moduleReference, message), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name)); + } + } + function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) { + var exportValue = moduleSymbol.exports.get("export="); + if (exportValue) { + return getPropertyOfType(getTypeOfSymbol(exportValue), name); + } + var exportSymbol = moduleSymbol.exports.get(name); + var resolved = resolveSymbol(exportSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, false); + return resolved; + } + function isSyntacticDefault(node) { + return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasModifier(node, 512) || ts.isExportSpecifier(node)); + } + function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias) { + if (!allowSyntheticDefaultImports) { + return false; + } + if (!file || file.isDeclarationFile) { + var defaultExportSymbol = resolveExportByName(moduleSymbol, "default", undefined, true); + if (defaultExportSymbol && ts.some(defaultExportSymbol.declarations, isSyntacticDefault)) { + return false; + } + if (resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias)) { + return false; + } + return true; + } + if (!ts.isSourceFileJS(file)) { + return hasExportAssignmentSymbol(moduleSymbol); + } + return !file.externalModuleIndicator && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias); + } + function getTargetOfImportClause(node, dontResolveAlias) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + var exportDefaultSymbol = void 0; + if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + exportDefaultSymbol = moduleSymbol; + } + else { + exportDefaultSymbol = resolveExportByName(moduleSymbol, "default", node, dontResolveAlias); + } + var file = ts.find(moduleSymbol.declarations, ts.isSourceFile); + var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias); + if (!exportDefaultSymbol && !hasSyntheticDefault) { + if (hasExportAssignmentSymbol(moduleSymbol)) { + var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop"; + var exportEqualsSymbol = moduleSymbol.exports.get("export="); + var exportAssignment = exportEqualsSymbol.valueDeclaration; + var err = error(node.name, ts.Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName); + ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName)); + } + else { + if (moduleSymbol.exports && moduleSymbol.exports.has(node.symbol.escapedName)) { + error(node.name, ts.Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead, symbolToString(moduleSymbol), symbolToString(node.symbol)); + } + else { + error(node.name, ts.Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol)); + } + } + } + else if (hasSyntheticDefault) { + var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, false); + return resolved; + } + markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, undefined, false); + return exportDefaultSymbol; + } + } + function getTargetOfNamespaceImport(node, dontResolveAlias) { + var moduleSpecifier = node.parent.parent.moduleSpecifier; + var immediate = resolveExternalModuleName(node, moduleSpecifier); + var resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false); + return resolved; + } + function getTargetOfNamespaceExport(node, dontResolveAlias) { + var moduleSpecifier = node.parent.moduleSpecifier; + var immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier); + var resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false); + return resolved; + } + function combineValueAndTypeSymbols(valueSymbol, typeSymbol) { + if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) { + return unknownSymbol; + } + if (valueSymbol.flags & (788968 | 1920)) { + return valueSymbol; + } + var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName); + result.declarations = ts.deduplicate(ts.concatenate(valueSymbol.declarations, typeSymbol.declarations), ts.equateValues); + result.parent = valueSymbol.parent || typeSymbol.parent; + if (valueSymbol.valueDeclaration) + result.valueDeclaration = valueSymbol.valueDeclaration; + if (typeSymbol.members) + result.members = ts.cloneMap(typeSymbol.members); + if (valueSymbol.exports) + result.exports = ts.cloneMap(valueSymbol.exports); + return result; + } + function getExportOfModule(symbol, specifier, dontResolveAlias) { + var _a; + if (symbol.flags & 1536) { + var name = ((_a = specifier.propertyName) !== null && _a !== void 0 ? _a : specifier.name).escapedText; + var exportSymbol = getExportsOfSymbol(symbol).get(name); + var resolved = resolveSymbol(exportSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, false); + return resolved; + } + } + function getPropertyOfVariable(symbol, name) { + if (symbol.flags & 3) { + var typeAnnotation = symbol.valueDeclaration.type; + if (typeAnnotation) { + return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name)); + } + } + } + function getExternalModuleMember(node, specifier, dontResolveAlias) { + if (dontResolveAlias === void 0) { dontResolveAlias = false; } + var _a; + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + var name = specifier.propertyName || specifier.name; + var suppressInteropError = name.escapedText === "default" && !!(compilerOptions.allowSyntheticDefaultImports || compilerOptions.esModuleInterop); + var targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier, dontResolveAlias, suppressInteropError); + if (targetSymbol) { + if (name.escapedText) { + if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + return moduleSymbol; + } + var symbolFromVariable = void 0; + if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=")) { + symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText); + } + else { + symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText); + } + symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias); + var symbolFromModule = getExportOfModule(targetSymbol, specifier, dontResolveAlias); + if (symbolFromModule === undefined && name.escapedText === "default") { + var file = ts.find(moduleSymbol.declarations, ts.isSourceFile); + if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) { + symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); + } + } + var symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ? + combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : + symbolFromModule || symbolFromVariable; + if (!symbol) { + var moduleName = getFullyQualifiedName(moduleSymbol, node); + var declarationName = ts.declarationNameToString(name); + var suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol); + if (suggestion !== undefined) { + var suggestionName = symbolToString(suggestion); + var diagnostic = error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_2, moduleName, declarationName, suggestionName); + if (suggestion.valueDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName)); + } + } + else { + if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has("default")) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, moduleName, declarationName); + } + else { + reportNonExportedMember(name, declarationName, moduleSymbol, moduleName); + } + } + } + return symbol; + } + } + } + function reportNonExportedMember(name, declarationName, moduleSymbol, moduleName) { + var _a; + var localSymbol = (_a = moduleSymbol.valueDeclaration.locals) === null || _a === void 0 ? void 0 : _a.get(name.escapedText); + var exports = moduleSymbol.exports; + if (localSymbol) { + var exportedSymbol = exports && !exports.has("export=") + ? ts.find(symbolsToArray(exports), function (symbol) { return !!getSymbolIfSameReference(symbol, localSymbol); }) + : undefined; + var diagnostic = exportedSymbol + ? error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) + : error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName); + ts.addRelatedInfo.apply(void 0, __spreadArrays([diagnostic], ts.map(localSymbol.declarations, function (decl, index) { + return ts.createDiagnosticForNode(decl, index === 0 ? ts.Diagnostics._0_is_declared_here : ts.Diagnostics.and_here, declarationName); + }))); + } + else { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName); + } + } + function getTargetOfImportSpecifier(node, dontResolveAlias) { + var resolved = getExternalModuleMember(node.parent.parent.parent, node, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false); + return resolved; + } + function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) { + var resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false); + return resolved; + } + function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) { + var resolved = node.parent.parent.moduleSpecifier ? + getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : + resolveEntityName(node.propertyName || node.name, meaning, false, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false); + return resolved; + } + function getTargetOfExportAssignment(node, dontResolveAlias) { + var expression = (ts.isExportAssignment(node) ? node.expression : node.right); + var resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false); + return resolved; + } + function getTargetOfAliasLikeExpression(expression, dontResolveAlias) { + if (ts.isClassExpression(expression)) { + return checkExpressionCached(expression).symbol; + } + if (!ts.isEntityName(expression) && !ts.isEntityNameExpression(expression)) { + return undefined; + } + var aliasLike = resolveEntityName(expression, 111551 | 788968 | 1920, true, dontResolveAlias); + if (aliasLike) { + return aliasLike; + } + checkExpressionCached(expression); + return getNodeLinks(expression).resolvedSymbol; + } + function getTargetOfPropertyAssignment(node, dontRecursivelyResolve) { + var expression = node.initializer; + return getTargetOfAliasLikeExpression(expression, dontRecursivelyResolve); + } + function getTargetOfPropertyAccessExpression(node, dontRecursivelyResolve) { + if (!(ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62)) { + return undefined; + } + return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve); + } + function getTargetOfAliasDeclaration(node, dontRecursivelyResolve) { + if (dontRecursivelyResolve === void 0) { dontRecursivelyResolve = false; } + switch (node.kind) { + case 253: + return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve); + case 255: + return getTargetOfImportClause(node, dontRecursivelyResolve); + case 256: + return getTargetOfNamespaceImport(node, dontRecursivelyResolve); + case 262: + return getTargetOfNamespaceExport(node, dontRecursivelyResolve); + case 258: + return getTargetOfImportSpecifier(node, dontRecursivelyResolve); + case 263: + return getTargetOfExportSpecifier(node, 111551 | 788968 | 1920, dontRecursivelyResolve); + case 259: + case 209: + return getTargetOfExportAssignment(node, dontRecursivelyResolve); + case 252: + return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve); + case 282: + return resolveEntityName(node.name, 111551 | 788968 | 1920, true, dontRecursivelyResolve); + case 281: + return getTargetOfPropertyAssignment(node, dontRecursivelyResolve); + case 194: + return getTargetOfPropertyAccessExpression(node, dontRecursivelyResolve); + default: + return ts.Debug.fail(); + } + } + function isNonLocalAlias(symbol, excludes) { + if (excludes === void 0) { excludes = 111551 | 788968 | 1920; } + if (!symbol) + return false; + return (symbol.flags & (2097152 | excludes)) === 2097152 || !!(symbol.flags & 2097152 && symbol.flags & 67108864); + } + function resolveSymbol(symbol, dontResolveAlias) { + return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol; + } + function resolveAlias(symbol) { + ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here."); + var links = getSymbolLinks(symbol); + if (!links.target) { + links.target = resolvingSymbol; + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + var target = getTargetOfAliasDeclaration(node); + if (links.target === resolvingSymbol) { + links.target = target || unknownSymbol; + } + else { + error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol)); + } + } + else if (links.target === resolvingSymbol) { + links.target = unknownSymbol; + } + return links.target; + } + function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) { + if (!aliasDeclaration) + return false; + var sourceSymbol = getSymbolOfNode(aliasDeclaration); + if (ts.isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) { + var links_1 = getSymbolLinks(sourceSymbol); + links_1.typeOnlyDeclaration = aliasDeclaration; + return true; + } + var links = getSymbolLinks(sourceSymbol); + return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty) + || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty); + } + function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) { + var _a, _b, _c; + if (target && (aliasDeclarationLinks.typeOnlyDeclaration === undefined || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) { + var exportSymbol = (_b = (_a = target.exports) === null || _a === void 0 ? void 0 : _a.get("export=")) !== null && _b !== void 0 ? _b : target; + var typeOnly = exportSymbol.declarations && ts.find(exportSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration); + aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly !== null && typeOnly !== void 0 ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) !== null && _c !== void 0 ? _c : false; + } + return !!aliasDeclarationLinks.typeOnlyDeclaration; + } + function getTypeOnlyAliasDeclaration(symbol) { + if (!(symbol.flags & 2097152)) { + return undefined; + } + var links = getSymbolLinks(symbol); + return links.typeOnlyDeclaration || undefined; + } + function markExportAsReferenced(node) { + var symbol = getSymbolOfNode(node); + var target = resolveAlias(symbol); + if (target) { + var markAlias = target === unknownSymbol || + ((target.flags & 111551) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol)); + if (markAlias) { + markAliasSymbolAsReferenced(symbol); + } + } + } + function markAliasSymbolAsReferenced(symbol) { + var links = getSymbolLinks(symbol); + if (!links.referenced) { + links.referenced = true; + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + var target = resolveSymbol(symbol); + if (target === unknownSymbol || target.flags & 111551) { + checkExpressionCached(node.moduleReference); + } + } + } + } + function markConstEnumAliasAsReferenced(symbol) { + var links = getSymbolLinks(symbol); + if (!links.constEnumReferenced) { + links.constEnumReferenced = true; + } + } + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) { + if (entityName.kind === 75 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { + entityName = entityName.parent; + } + if (entityName.kind === 75 || entityName.parent.kind === 153) { + return resolveEntityName(entityName, 1920, false, dontResolveAlias); + } + else { + ts.Debug.assert(entityName.parent.kind === 253); + return resolveEntityName(entityName, 111551 | 788968 | 1920, false, dontResolveAlias); + } + } + function getFullyQualifiedName(symbol, containingLocation) { + return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, undefined, 16 | 4); + } + function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location) { + if (ts.nodeIsMissing(name)) { + return undefined; + } + var namespaceMeaning = 1920 | (ts.isInJSFile(name) ? meaning & 111551 : 0); + var symbol; + if (name.kind === 75) { + var message = meaning === namespaceMeaning ? ts.Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(ts.getFirstIdentifier(name)); + var symbolFromJSPrototype = ts.isInJSFile(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : undefined; + symbol = resolveName(location || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? undefined : message, name, true); + if (!symbol) { + return symbolFromJSPrototype; + } + } + else if (name.kind === 153 || name.kind === 194) { + var left = name.kind === 153 ? name.left : name.expression; + var right = name.kind === 153 ? name.right : name.name; + var namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, false, location); + if (!namespace || ts.nodeIsMissing(right)) { + return undefined; + } + else if (namespace === unknownSymbol) { + return namespace; + } + if (ts.isInJSFile(name)) { + if (namespace.valueDeclaration && + ts.isVariableDeclaration(namespace.valueDeclaration) && + namespace.valueDeclaration.initializer && + isCommonJsRequire(namespace.valueDeclaration.initializer)) { + var moduleName = namespace.valueDeclaration.initializer.arguments[0]; + var moduleSym = resolveExternalModuleName(moduleName, moduleName); + if (moduleSym) { + var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym); + if (resolvedModuleSymbol) { + namespace = resolvedModuleSymbol; + } + } + } + } + symbol = getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning); + if (!symbol) { + if (!ignoreErrors) { + error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(right)); + } + return undefined; + } + } + else { + throw ts.Debug.assertNever(name, "Unknown entity name kind."); + } + ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here."); + if (ts.isEntityName(name) && (symbol.flags & 2097152 || name.parent.kind === 259)) { + markSymbolOfAliasDeclarationIfTypeOnly(ts.getAliasDeclarationFromName(name), symbol, undefined, true); + } + return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol); + } + function resolveEntityNameFromAssignmentDeclaration(name, meaning) { + if (isJSDocTypeReference(name.parent)) { + var secondaryLocation = getAssignmentDeclarationLocation(name.parent); + if (secondaryLocation) { + return resolveName(secondaryLocation, name.escapedText, meaning, undefined, name, true); + } + } + } + function getAssignmentDeclarationLocation(node) { + var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 4194304) ? "quit" : ts.isJSDocTypeAlias(node); }); + if (typeAlias) { + return; + } + var host = ts.getJSDocHost(node); + if (ts.isExpressionStatement(host) && + ts.isBinaryExpression(host.expression) && + ts.getAssignmentDeclarationKind(host.expression) === 3) { + var symbol = getSymbolOfNode(host.expression.left); + if (symbol) { + return getDeclarationOfJSPrototypeContainer(symbol); + } + } + if ((ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) && + ts.isBinaryExpression(host.parent.parent) && + ts.getAssignmentDeclarationKind(host.parent.parent) === 6) { + var symbol = getSymbolOfNode(host.parent.parent.left); + if (symbol) { + return getDeclarationOfJSPrototypeContainer(symbol); + } + } + var sig = ts.getHostSignatureFromJSDocHost(host); + if (sig) { + var symbol = getSymbolOfNode(sig); + return symbol && symbol.valueDeclaration; + } + } + function getDeclarationOfJSPrototypeContainer(symbol) { + var decl = symbol.parent.valueDeclaration; + if (!decl) { + return undefined; + } + var initializer = ts.isAssignmentDeclaration(decl) ? ts.getAssignedExpandoInitializer(decl) : + ts.hasOnlyExpressionInitializer(decl) ? ts.getDeclaredExpandoInitializer(decl) : + undefined; + return initializer || decl; + } + function getExpandoSymbol(symbol) { + var decl = symbol.valueDeclaration; + if (!decl || !ts.isInJSFile(decl) || symbol.flags & 524288 || ts.getExpandoInitializer(decl, false)) { + return undefined; + } + var init = ts.isVariableDeclaration(decl) ? ts.getDeclaredExpandoInitializer(decl) : ts.getAssignedExpandoInitializer(decl); + if (init) { + var initSymbol = getSymbolOfNode(init); + if (initSymbol) { + return mergeJSSymbols(initSymbol, symbol); + } + } + } + function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) { + return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : ts.Diagnostics.Cannot_find_module_0); + } + function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, isForAugmentation) { + if (isForAugmentation === void 0) { isForAugmentation = false; } + return ts.isStringLiteralLike(moduleReferenceExpression) + ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation) + : undefined; + } + function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) { + if (isForAugmentation === void 0) { isForAugmentation = false; } + if (ts.startsWith(moduleReference, "@types/")) { + var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1; + var withoutAtTypePrefix = ts.removePrefix(moduleReference, "@types/"); + error(errorNode, diag, withoutAtTypePrefix, moduleReference); + } + var ambientModule = tryFindAmbientModule(moduleReference, true); + if (ambientModule) { + return ambientModule; + } + var currentSourceFile = ts.getSourceFileOfNode(location); + var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference); + var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule); + var sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName); + if (sourceFile) { + if (sourceFile.symbol) { + if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) { + errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference); + } + return getMergedSymbol(sourceFile.symbol); + } + if (moduleNotFoundError) { + error(errorNode, ts.Diagnostics.File_0_is_not_a_module, sourceFile.fileName); + } + return undefined; + } + if (patternAmbientModules) { + var pattern = ts.findBestPatternMatch(patternAmbientModules, function (_) { return _.pattern; }, moduleReference); + if (pattern) { + var augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference); + if (augmentation) { + return getMergedSymbol(augmentation); + } + return getMergedSymbol(pattern.symbol); + } + } + if (resolvedModule && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === undefined || resolutionDiagnostic === ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) { + if (isForAugmentation) { + var diag = ts.Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented; + error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName); + } + else { + errorOnImplicitAnyModule(noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference); + } + return undefined; + } + if (moduleNotFoundError) { + if (resolvedModule) { + var redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName); + if (redirect) { + error(errorNode, ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName); + return undefined; + } + } + if (resolutionDiagnostic) { + error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName); + } + else { + var tsExtension = ts.tryExtractTSExtension(moduleReference); + if (tsExtension) { + var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead; + error(errorNode, diag, tsExtension, ts.removeExtension(moduleReference, tsExtension)); + } + else if (!compilerOptions.resolveJsonModule && + ts.fileExtensionIs(moduleReference, ".json") && + ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && + ts.hasJsonModuleEmitEnabled(compilerOptions)) { + error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference); + } + else { + error(errorNode, moduleNotFoundError, moduleReference); + } + } + } + return undefined; + } + function errorOnImplicitAnyModule(isError, errorNode, _a, moduleReference) { + var packageId = _a.packageId, resolvedFileName = _a.resolvedFileName; + var errorInfo = !ts.isExternalModuleNameRelative(moduleReference) && packageId + ? typesPackageExists(packageId.name) + ? ts.chainDiagnosticMessages(undefined, ts.Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, packageId.name, ts.mangleScopedPackageName(packageId.name)) + : ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, moduleReference, ts.mangleScopedPackageName(packageId.name)) + : undefined; + errorOrSuggestion(isError, errorNode, ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedFileName)); + } + function typesPackageExists(packageName) { + return getPackagesSet().has(ts.getTypesPackageName(packageName)); + } + function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) { + if (moduleSymbol) { + var exportEquals = resolveSymbol(moduleSymbol.exports.get("export="), dontResolveAlias); + var exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol)); + return getMergedSymbol(exported) || moduleSymbol; + } + return undefined; + } + function getCommonJsExportEquals(exported, moduleSymbol) { + if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152) { + return exported; + } + var links = getSymbolLinks(exported); + if (links.cjsExportMerged) { + return links.cjsExportMerged; + } + var merged = exported.flags & 33554432 ? exported : cloneSymbol(exported); + merged.flags = merged.flags | 512; + if (merged.exports === undefined) { + merged.exports = ts.createSymbolTable(); + } + moduleSymbol.exports.forEach(function (s, name) { + if (name === "export=") + return; + merged.exports.set(name, merged.exports.has(name) ? mergeSymbol(merged.exports.get(name), s) : s); + }); + getSymbolLinks(merged).cjsExportMerged = merged; + return links.cjsExportMerged = merged; + } + function resolveESModuleSymbol(moduleSymbol, referencingLocation, dontResolveAlias, suppressInteropError) { + var symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias); + if (!dontResolveAlias && symbol) { + if (!suppressInteropError && !(symbol.flags & (1536 | 3)) && !ts.getDeclarationOfKind(symbol, 290)) { + var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 + ? "allowSyntheticDefaultImports" + : "esModuleInterop"; + error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName); + return symbol; + } + if (compilerOptions.esModuleInterop) { + var referenceParent = referencingLocation.parent; + if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) || + ts.isImportCall(referenceParent)) { + var type = getTypeOfSymbol(symbol); + var sigs = getSignaturesOfStructuredType(type, 0); + if (!sigs || !sigs.length) { + sigs = getSignaturesOfStructuredType(type, 1); + } + if (sigs && sigs.length) { + var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol); + var result = createSymbol(symbol.flags, symbol.escapedName); + result.declarations = symbol.declarations ? symbol.declarations.slice() : []; + result.parent = symbol.parent; + result.target = symbol; + result.originatingImport = referenceParent; + if (symbol.valueDeclaration) + result.valueDeclaration = symbol.valueDeclaration; + if (symbol.constEnumOnlyModule) + result.constEnumOnlyModule = true; + if (symbol.members) + result.members = ts.cloneMap(symbol.members); + if (symbol.exports) + result.exports = ts.cloneMap(symbol.exports); + var resolvedModuleType = resolveStructuredTypeMembers(moduleType); + result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.stringIndexInfo, resolvedModuleType.numberIndexInfo); + return result; + } + } + } + } + return symbol; + } + function hasExportAssignmentSymbol(moduleSymbol) { + return moduleSymbol.exports.get("export=") !== undefined; + } + function getExportsOfModuleAsArray(moduleSymbol) { + return symbolsToArray(getExportsOfModule(moduleSymbol)); + } + function getExportsAndPropertiesOfModule(moduleSymbol) { + var exports = getExportsOfModuleAsArray(moduleSymbol); + var exportEquals = resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals !== moduleSymbol) { + ts.addRange(exports, getPropertiesOfType(getTypeOfSymbol(exportEquals))); + } + return exports; + } + function tryGetMemberInModuleExports(memberName, moduleSymbol) { + var symbolTable = getExportsOfModule(moduleSymbol); + if (symbolTable) { + return symbolTable.get(memberName); + } + } + function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) { + var symbol = tryGetMemberInModuleExports(memberName, moduleSymbol); + if (symbol) { + return symbol; + } + var exportEquals = resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals === moduleSymbol) { + return undefined; + } + var type = getTypeOfSymbol(exportEquals); + return type.flags & 131068 || + ts.getObjectFlags(type) & 1 || + isArrayOrTupleLikeType(type) + ? undefined + : getPropertyOfType(type, memberName); + } + function getExportsOfSymbol(symbol) { + return symbol.flags & 6256 ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports") : + symbol.flags & 1536 ? getExportsOfModule(symbol) : + symbol.exports || emptySymbols; + } + function getExportsOfModule(moduleSymbol) { + var links = getSymbolLinks(moduleSymbol); + return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol)); + } + function extendExportSymbols(target, source, lookupTable, exportNode) { + if (!source) + return; + source.forEach(function (sourceSymbol, id) { + if (id === "default") + return; + var targetSymbol = target.get(id); + if (!targetSymbol) { + target.set(id, sourceSymbol); + if (lookupTable && exportNode) { + lookupTable.set(id, { + specifierText: ts.getTextOfNode(exportNode.moduleSpecifier) + }); + } + } + else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) { + var collisionTracker = lookupTable.get(id); + if (!collisionTracker.exportsWithDuplicate) { + collisionTracker.exportsWithDuplicate = [exportNode]; + } + else { + collisionTracker.exportsWithDuplicate.push(exportNode); + } + } + }); + } + function getExportsOfModuleWorker(moduleSymbol) { + var visitedSymbols = []; + moduleSymbol = resolveExternalModuleSymbol(moduleSymbol); + return visit(moduleSymbol) || emptySymbols; + function visit(symbol) { + if (!(symbol && symbol.exports && ts.pushIfUnique(visitedSymbols, symbol))) { + return; + } + var symbols = ts.cloneMap(symbol.exports); + var exportStars = symbol.exports.get("__export"); + if (exportStars) { + var nestedSymbols = ts.createSymbolTable(); + var lookupTable_1 = ts.createMap(); + for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) { + var node = _a[_i]; + var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier); + var exportedSymbols = visit(resolvedModule); + extendExportSymbols(nestedSymbols, exportedSymbols, lookupTable_1, node); + } + lookupTable_1.forEach(function (_a, id) { + var exportsWithDuplicate = _a.exportsWithDuplicate; + if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) { + return; + } + for (var _i = 0, exportsWithDuplicate_1 = exportsWithDuplicate; _i < exportsWithDuplicate_1.length; _i++) { + var node = exportsWithDuplicate_1[_i]; + diagnostics.add(ts.createDiagnosticForNode(node, ts.Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, lookupTable_1.get(id).specifierText, ts.unescapeLeadingUnderscores(id))); + } + }); + extendExportSymbols(symbols, nestedSymbols); + } + return symbols; + } + } + function getMergedSymbol(symbol) { + var merged; + return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; + } + function getSymbolOfNode(node) { + return getMergedSymbol(node.symbol && getLateBoundSymbol(node.symbol)); + } + function getParentOfSymbol(symbol) { + return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent)); + } + function getAlternativeContainingModules(symbol, enclosingDeclaration) { + var containingFile = ts.getSourceFileOfNode(enclosingDeclaration); + var id = "" + getNodeId(containingFile); + var links = getSymbolLinks(symbol); + var results; + if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) { + return results; + } + if (containingFile && containingFile.imports) { + for (var _i = 0, _a = containingFile.imports; _i < _a.length; _i++) { + var importRef = _a[_i]; + if (ts.nodeIsSynthesized(importRef)) + continue; + var resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, true); + if (!resolvedModule) + continue; + var ref = getAliasForSymbolInContainer(resolvedModule, symbol); + if (!ref) + continue; + results = ts.append(results, resolvedModule); + } + if (ts.length(results)) { + (links.extendedContainersByFile || (links.extendedContainersByFile = ts.createMap())).set(id, results); + return results; + } + } + if (links.extendedContainers) { + return links.extendedContainers; + } + var otherFiles = host.getSourceFiles(); + for (var _b = 0, otherFiles_1 = otherFiles; _b < otherFiles_1.length; _b++) { + var file = otherFiles_1[_b]; + if (!ts.isExternalModule(file)) + continue; + var sym = getSymbolOfNode(file); + var ref = getAliasForSymbolInContainer(sym, symbol); + if (!ref) + continue; + results = ts.append(results, sym); + } + return links.extendedContainers = results || ts.emptyArray; + } + function getContainersOfSymbol(symbol, enclosingDeclaration) { + var container = getParentOfSymbol(symbol); + if (container && !(symbol.flags & 262144)) { + var additionalContainers = ts.mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer); + var reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration); + if (enclosingDeclaration && getAccessibleSymbolChain(container, enclosingDeclaration, 1920, false)) { + return ts.concatenate(ts.concatenate([container], additionalContainers), reexportContainers); + } + var res = ts.append(additionalContainers, container); + return ts.concatenate(res, reexportContainers); + } + var candidates = ts.mapDefined(symbol.declarations, function (d) { + if (!ts.isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) { + return getSymbolOfNode(d.parent); + } + if (ts.isClassExpression(d) && ts.isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 62 && ts.isAccessExpression(d.parent.left) && ts.isEntityNameExpression(d.parent.left.expression)) { + if (ts.isModuleExportsAccessExpression(d.parent.left) || ts.isExportsIdentifier(d.parent.left.expression)) { + return getSymbolOfNode(ts.getSourceFileOfNode(d)); + } + checkExpressionCached(d.parent.left.expression); + return getNodeLinks(d.parent.left.expression).resolvedSymbol; + } + }); + if (!ts.length(candidates)) { + return undefined; + } + return ts.mapDefined(candidates, function (candidate) { return getAliasForSymbolInContainer(candidate, symbol) ? candidate : undefined; }); + function fileSymbolIfFileSymbolExportEqualsContainer(d) { + var fileSymbol = getExternalModuleContainer(d); + var exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export="); + return exported && container && getSymbolIfSameReference(exported, container) ? fileSymbol : undefined; + } + } + function getAliasForSymbolInContainer(container, symbol) { + if (container === getParentOfSymbol(symbol)) { + return symbol; + } + var exportEquals = container.exports && container.exports.get("export="); + if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) { + return container; + } + var exports = getExportsOfSymbol(container); + var quick = exports.get(symbol.escapedName); + if (quick && getSymbolIfSameReference(quick, symbol)) { + return quick; + } + return ts.forEachEntry(exports, function (exported) { + if (getSymbolIfSameReference(exported, symbol)) { + return exported; + } + }); + } + function getSymbolIfSameReference(s1, s2) { + if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) { + return s1; + } + } + function getExportSymbolOfValueSymbolIfExported(symbol) { + return getMergedSymbol(symbol && (symbol.flags & 1048576) !== 0 ? symbol.exportSymbol : symbol); + } + function symbolIsValue(symbol) { + return !!(symbol.flags & 111551 || symbol.flags & 2097152 && resolveAlias(symbol).flags & 111551 && !getTypeOnlyAliasDeclaration(symbol)); + } + function findConstructorDeclaration(node) { + var members = node.members; + for (var _i = 0, members_3 = members; _i < members_3.length; _i++) { + var member = members_3[_i]; + if (member.kind === 162 && ts.nodeIsPresent(member.body)) { + return member; + } + } + } + function createType(flags) { + var result = new Type(checker, flags); + typeCount++; + result.id = typeCount; + return result; + } + function createIntrinsicType(kind, intrinsicName, objectFlags) { + if (objectFlags === void 0) { objectFlags = 0; } + var type = createType(kind); + type.intrinsicName = intrinsicName; + type.objectFlags = objectFlags; + return type; + } + function createBooleanType(trueFalseTypes) { + var type = getUnionType(trueFalseTypes); + type.flags |= 16; + type.intrinsicName = "boolean"; + return type; + } + function createObjectType(objectFlags, symbol) { + var type = createType(524288); + type.objectFlags = objectFlags; + type.symbol = symbol; + type.members = undefined; + type.properties = undefined; + type.callSignatures = undefined; + type.constructSignatures = undefined; + type.stringIndexInfo = undefined; + type.numberIndexInfo = undefined; + return type; + } + function createTypeofType() { + return getUnionType(ts.arrayFrom(typeofEQFacts.keys(), getLiteralType)); + } + function createTypeParameter(symbol) { + var type = createType(262144); + if (symbol) + type.symbol = symbol; + return type; + } + function isReservedMemberName(name) { + return name.charCodeAt(0) === 95 && + name.charCodeAt(1) === 95 && + name.charCodeAt(2) !== 95 && + name.charCodeAt(2) !== 64 && + name.charCodeAt(2) !== 35; + } + function getNamedMembers(members) { + var result; + members.forEach(function (symbol, id) { + if (!isReservedMemberName(id) && symbolIsValue(symbol)) { + (result || (result = [])).push(symbol); + } + }); + return result || ts.emptyArray; + } + function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) { + type.members = members; + type.properties = members === emptySymbols ? ts.emptyArray : getNamedMembers(members); + type.callSignatures = callSignatures; + type.constructSignatures = constructSignatures; + type.stringIndexInfo = stringIndexInfo; + type.numberIndexInfo = numberIndexInfo; + return type; + } + function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) { + return setStructuredTypeMembers(createObjectType(16, symbol), members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + } + function forEachSymbolTableInScope(enclosingDeclaration, callback) { + var result; + var _loop_6 = function (location) { + if (location.locals && !isGlobalSourceFile(location)) { + if (result = callback(location.locals)) { + return { value: result }; + } + } + switch (location.kind) { + case 290: + if (!ts.isExternalOrCommonJsModule(location)) { + break; + } + case 249: + var sym = getSymbolOfNode(location); + if (result = callback((sym === null || sym === void 0 ? void 0 : sym.exports) || emptySymbols)) { + return { value: result }; + } + break; + case 245: + case 214: + case 246: + var table_1; + (getSymbolOfNode(location).members || emptySymbols).forEach(function (memberSymbol, key) { + if (memberSymbol.flags & (788968 & ~67108864)) { + (table_1 || (table_1 = ts.createSymbolTable())).set(key, memberSymbol); + } + }); + if (table_1 && (result = callback(table_1))) { + return { value: result }; + } + break; + } + }; + for (var location = enclosingDeclaration; location; location = location.parent) { + var state_2 = _loop_6(location); + if (typeof state_2 === "object") + return state_2.value; + } + return callback(globals); + } + function getQualifiedLeftMeaning(rightMeaning) { + return rightMeaning === 111551 ? 111551 : 1920; + } + function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap) { + if (visitedSymbolTablesMap === void 0) { visitedSymbolTablesMap = ts.createMap(); } + if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) { + return undefined; + } + var id = "" + getSymbolId(symbol); + var visitedSymbolTables = visitedSymbolTablesMap.get(id); + if (!visitedSymbolTables) { + visitedSymbolTablesMap.set(id, visitedSymbolTables = []); + } + return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable); + function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification) { + if (!ts.pushIfUnique(visitedSymbolTables, symbols)) { + return undefined; + } + var result = trySymbolTable(symbols, ignoreQualification); + visitedSymbolTables.pop(); + return result; + } + function canQualifySymbol(symbolFromSymbolTable, meaning) { + return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning) || + !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing, visitedSymbolTablesMap); + } + function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) { + return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) && + !ts.some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) && + (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning)); + } + function trySymbolTable(symbols, ignoreQualification) { + if (isAccessible(symbols.get(symbol.escapedName), undefined, ignoreQualification)) { + return [symbol]; + } + var result = ts.forEachEntry(symbols, function (symbolFromSymbolTable) { + if (symbolFromSymbolTable.flags & 2097152 + && symbolFromSymbolTable.escapedName !== "export=" + && symbolFromSymbolTable.escapedName !== "default" + && !(ts.isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && ts.isExternalModule(ts.getSourceFileOfNode(enclosingDeclaration))) + && (!useOnlyExternalAliasing || ts.some(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) + && (ignoreQualification || !ts.getDeclarationOfKind(symbolFromSymbolTable, 263))) { + var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable); + var candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification); + if (candidate) { + return candidate; + } + } + if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) { + if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), undefined, ignoreQualification)) { + return [symbol]; + } + } + }); + return result || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : undefined); + } + function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) { + if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) { + return [symbolFromSymbolTable]; + } + var candidateTable = getExportsOfSymbol(resolvedImportedSymbol); + var accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, true); + if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) { + return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports); + } + } + } + function needsQualification(symbol, enclosingDeclaration, meaning) { + var qualify = false; + forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) { + var symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName)); + if (!symbolFromSymbolTable) { + return false; + } + if (symbolFromSymbolTable === symbol) { + return true; + } + symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 && !ts.getDeclarationOfKind(symbolFromSymbolTable, 263)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; + if (symbolFromSymbolTable.flags & meaning) { + qualify = true; + return true; + } + return false; + }); + return qualify; + } + function isPropertyOrMethodDeclarationSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + switch (declaration.kind) { + case 159: + case 161: + case 163: + case 164: + continue; + default: + return false; + } + } + return true; + } + return false; + } + function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) { + var access = isSymbolAccessible(typeSymbol, enclosingDeclaration, 788968, false); + return access.accessibility === 0; + } + function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) { + var access = isSymbolAccessible(typeSymbol, enclosingDeclaration, 111551, false); + return access.accessibility === 0; + } + function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible) { + if (!ts.length(symbols)) + return; + var hadAccessibleChain; + var earlyModuleBail = false; + for (var _i = 0, _a = symbols; _i < _a.length; _i++) { + var symbol = _a[_i]; + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, false); + if (accessibleSymbolChain) { + hadAccessibleChain = symbol; + var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible); + if (hasAccessibleDeclarations) { + return hasAccessibleDeclarations; + } + } + else { + if (ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + if (shouldComputeAliasesToMakeVisible) { + earlyModuleBail = true; + continue; + } + return { + accessibility: 0 + }; + } + } + var containers = getContainersOfSymbol(symbol, enclosingDeclaration); + var firstDecl = ts.first(symbol.declarations); + if (!ts.length(containers) && meaning & 111551 && firstDecl && ts.isObjectLiteralExpression(firstDecl)) { + if (firstDecl.parent && ts.isVariableDeclaration(firstDecl.parent) && firstDecl === firstDecl.parent.initializer) { + containers = [getSymbolOfNode(firstDecl.parent)]; + } + } + var parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible); + if (parentResult) { + return parentResult; + } + } + if (earlyModuleBail) { + return { + accessibility: 0 + }; + } + if (hadAccessibleChain) { + return { + accessibility: 1, + errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), + errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920) : undefined, + }; + } + } + function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) { + if (symbol && enclosingDeclaration) { + var result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible); + if (result) { + return result; + } + var symbolExternalModule = ts.forEach(symbol.declarations, getExternalModuleContainer); + if (symbolExternalModule) { + var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration); + if (symbolExternalModule !== enclosingExternalModule) { + return { + accessibility: 2, + errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning), + errorModuleName: symbolToString(symbolExternalModule) + }; + } + } + return { + accessibility: 1, + errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning), + }; + } + return { accessibility: 0 }; + } + function getExternalModuleContainer(declaration) { + var node = ts.findAncestor(declaration, hasExternalModuleSymbol); + return node && getSymbolOfNode(node); + } + function hasExternalModuleSymbol(declaration) { + return ts.isAmbientModule(declaration) || (declaration.kind === 290 && ts.isExternalOrCommonJsModule(declaration)); + } + function hasNonGlobalAugmentationExternalModuleSymbol(declaration) { + return ts.isModuleWithStringLiteralName(declaration) || (declaration.kind === 290 && ts.isExternalOrCommonJsModule(declaration)); + } + function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) { + var aliasesToMakeVisible; + if (!ts.every(ts.filter(symbol.declarations, function (d) { return d.kind !== 75; }), getIsDeclarationVisible)) { + return undefined; + } + return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; + function getIsDeclarationVisible(declaration) { + if (!isDeclarationVisible(declaration)) { + var anyImportSyntax = getAnyImportSyntax(declaration); + if (anyImportSyntax && + !ts.hasModifier(anyImportSyntax, 1) && + isDeclarationVisible(anyImportSyntax.parent)) { + return addVisibleAlias(declaration, anyImportSyntax); + } + else if (ts.isVariableDeclaration(declaration) && ts.isVariableStatement(declaration.parent.parent) && + !ts.hasModifier(declaration.parent.parent, 1) && + isDeclarationVisible(declaration.parent.parent.parent)) { + return addVisibleAlias(declaration, declaration.parent.parent); + } + else if (ts.isLateVisibilityPaintedStatement(declaration) + && !ts.hasModifier(declaration, 1) + && isDeclarationVisible(declaration.parent)) { + return addVisibleAlias(declaration, declaration); + } + return false; + } + return true; + } + function addVisibleAlias(declaration, aliasingStatement) { + if (shouldComputeAliasToMakeVisible) { + getNodeLinks(declaration).isVisible = true; + aliasesToMakeVisible = ts.appendIfUnique(aliasesToMakeVisible, aliasingStatement); + } + return true; + } + } + function isEntityNameVisible(entityName, enclosingDeclaration) { + var meaning; + if (entityName.parent.kind === 172 || + ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) || + entityName.parent.kind === 154) { + meaning = 111551 | 1048576; + } + else if (entityName.kind === 153 || entityName.kind === 194 || + entityName.parent.kind === 253) { + meaning = 1920; + } + else { + meaning = 788968; + } + var firstIdentifier = ts.getFirstIdentifier(entityName); + var symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, undefined, undefined, false); + return (symbol && hasVisibleDeclarations(symbol, true)) || { + accessibility: 1, + errorSymbolName: ts.getTextOfNode(firstIdentifier), + errorNode: firstIdentifier + }; + } + function symbolToString(symbol, enclosingDeclaration, meaning, flags, writer) { + if (flags === void 0) { flags = 4; } + var nodeFlags = 70221824; + if (flags & 2) { + nodeFlags |= 128; + } + if (flags & 1) { + nodeFlags |= 512; + } + if (flags & 8) { + nodeFlags |= 16384; + } + if (flags & 16) { + nodeFlags |= 134217728; + } + var builder = flags & 4 ? nodeBuilder.symbolToExpression : nodeBuilder.symbolToEntityName; + return writer ? symbolToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(symbolToStringWorker); + function symbolToStringWorker(writer) { + var entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags); + var printer = ts.createPrinter({ removeComments: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4, entity, sourceFile, writer); + return writer; + } + } + function signatureToString(signature, enclosingDeclaration, flags, kind, writer) { + if (flags === void 0) { flags = 0; } + return writer ? signatureToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(signatureToStringWorker); + function signatureToStringWorker(writer) { + var sigOutput; + if (flags & 262144) { + sigOutput = kind === 1 ? 171 : 170; + } + else { + sigOutput = kind === 1 ? 166 : 165; + } + var sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512); + var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4, sig, sourceFile, ts.getTrailingSemicolonDeferringWriter(writer)); + return writer; + } + } + function typeToString(type, enclosingDeclaration, flags, writer) { + if (flags === void 0) { flags = 1048576 | 16384; } + if (writer === void 0) { writer = ts.createTextWriter(""); } + var noTruncation = compilerOptions.noErrorTruncation || flags & 1; + var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | (noTruncation ? 1 : 0), writer); + if (typeNode === undefined) + return ts.Debug.fail("should always get typenode"); + var options = { removeComments: true }; + var printer = ts.createPrinter(options); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4, typeNode, sourceFile, writer); + var result = writer.getText(); + var maxLength = noTruncation ? undefined : ts.defaultMaximumTruncationLength * 2; + if (maxLength && result && result.length >= maxLength) { + return result.substr(0, maxLength - "...".length) + "..."; + } + return result; + } + function getTypeNamesForErrorDisplay(left, right) { + var leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left); + var rightStr = symbolValueDeclarationIsContextSensitive(right.symbol) ? typeToString(right, right.symbol.valueDeclaration) : typeToString(right); + if (leftStr === rightStr) { + leftStr = typeToString(left, undefined, 64); + rightStr = typeToString(right, undefined, 64); + } + return [leftStr, rightStr]; + } + function symbolValueDeclarationIsContextSensitive(symbol) { + return symbol && symbol.valueDeclaration && ts.isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration); + } + function toNodeBuilderFlags(flags) { + if (flags === void 0) { flags = 0; } + return flags & 277904747; + } + function createNodeBuilder() { + return { + typeToTypeNode: function (type, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeToTypeNodeHelper(type, context); }); + }, + indexInfoToIndexSignatureDeclaration: function (indexInfo, kind, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context); }); + }, + signatureToSignatureDeclaration: function (signature, kind, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return signatureToSignatureDeclarationHelper(signature, kind, context); }); + }, + symbolToEntityName: function (symbol, meaning, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToName(symbol, context, meaning, false); }); + }, + symbolToExpression: function (symbol, meaning, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToExpression(symbol, context, meaning); }); + }, + symbolToTypeParameterDeclarations: function (symbol, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParametersToTypeParameterDeclarations(symbol, context); }); + }, + symbolToParameterDeclaration: function (symbol, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToParameterDeclaration(symbol, context); }); + }, + typeParameterToDeclaration: function (parameter, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParameterToDeclaration(parameter, context); }); + }, + symbolTableToDeclarationStatements: function (symbolTable, enclosingDeclaration, flags, tracker, bundled) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolTableToDeclarationStatements(symbolTable, context, bundled); }); + }, + }; + function withContext(enclosingDeclaration, flags, tracker, cb) { + ts.Debug.assert(enclosingDeclaration === undefined || (enclosingDeclaration.flags & 8) === 0); + var context = { + enclosingDeclaration: enclosingDeclaration, + flags: flags || 0, + tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: ts.noop, moduleResolverHost: flags & 134217728 ? { + getCommonSourceDirectory: host.getCommonSourceDirectory ? function () { return host.getCommonSourceDirectory(); } : function () { return ""; }, + getSourceFiles: function () { return host.getSourceFiles(); }, + getCurrentDirectory: ts.maybeBind(host, host.getCurrentDirectory), + getProbableSymlinks: ts.maybeBind(host, host.getProbableSymlinks), + } : undefined }, + encounteredError: false, + visitedTypes: undefined, + symbolDepth: undefined, + inferTypeParameters: undefined, + approximateLength: 0 + }; + var resultingNode = cb(context); + return context.encounteredError ? undefined : resultingNode; + } + function checkTruncationLength(context) { + if (context.truncating) + return context.truncating; + return context.truncating = !(context.flags & 1) && context.approximateLength > ts.defaultMaximumTruncationLength; + } + function typeToTypeNodeHelper(type, context) { + if (cancellationToken && cancellationToken.throwIfCancellationRequested) { + cancellationToken.throwIfCancellationRequested(); + } + var inTypeAlias = context.flags & 8388608; + context.flags &= ~8388608; + if (!type) { + context.encounteredError = true; + return undefined; + } + if (type.flags & 1) { + context.approximateLength += 3; + return ts.createKeywordTypeNode(125); + } + if (type.flags & 2) { + return ts.createKeywordTypeNode(148); + } + if (type.flags & 4) { + context.approximateLength += 6; + return ts.createKeywordTypeNode(143); + } + if (type.flags & 8) { + context.approximateLength += 6; + return ts.createKeywordTypeNode(140); + } + if (type.flags & 64) { + context.approximateLength += 6; + return ts.createKeywordTypeNode(151); + } + if (type.flags & 16) { + context.approximateLength += 7; + return ts.createKeywordTypeNode(128); + } + if (type.flags & 1024 && !(type.flags & 1048576)) { + var parentSymbol = getParentOfSymbol(type.symbol); + var parentName = symbolToTypeNode(parentSymbol, context, 788968); + var enumLiteralName = getDeclaredTypeOfSymbol(parentSymbol) === type + ? parentName + : appendReferenceToType(parentName, ts.createTypeReferenceNode(ts.symbolName(type.symbol), undefined)); + return enumLiteralName; + } + if (type.flags & 1056) { + return symbolToTypeNode(type.symbol, context, 788968); + } + if (type.flags & 128) { + context.approximateLength += (type.value.length + 2); + return ts.createLiteralTypeNode(ts.setEmitFlags(ts.createLiteral(type.value, !!(context.flags & 268435456)), 16777216)); + } + if (type.flags & 256) { + var value = type.value; + context.approximateLength += ("" + value).length; + return ts.createLiteralTypeNode(value < 0 ? ts.createPrefix(40, ts.createLiteral(-value)) : ts.createLiteral(value)); + } + if (type.flags & 2048) { + context.approximateLength += (ts.pseudoBigIntToString(type.value).length) + 1; + return ts.createLiteralTypeNode((ts.createLiteral(type.value))); + } + if (type.flags & 512) { + context.approximateLength += type.intrinsicName.length; + return type.intrinsicName === "true" ? ts.createTrue() : ts.createFalse(); + } + if (type.flags & 8192) { + if (!(context.flags & 1048576)) { + if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + context.approximateLength += 6; + return symbolToTypeNode(type.symbol, context, 111551); + } + if (context.tracker.reportInaccessibleUniqueSymbolError) { + context.tracker.reportInaccessibleUniqueSymbolError(); + } + } + context.approximateLength += 13; + return ts.createTypeOperatorNode(147, ts.createKeywordTypeNode(144)); + } + if (type.flags & 16384) { + context.approximateLength += 4; + return ts.createKeywordTypeNode(110); + } + if (type.flags & 32768) { + context.approximateLength += 9; + return ts.createKeywordTypeNode(146); + } + if (type.flags & 65536) { + context.approximateLength += 4; + return ts.createKeywordTypeNode(100); + } + if (type.flags & 131072) { + context.approximateLength += 5; + return ts.createKeywordTypeNode(137); + } + if (type.flags & 4096) { + context.approximateLength += 6; + return ts.createKeywordTypeNode(144); + } + if (type.flags & 67108864) { + context.approximateLength += 6; + return ts.createKeywordTypeNode(141); + } + if (isThisTypeParameter(type)) { + if (context.flags & 4194304) { + if (!context.encounteredError && !(context.flags & 32768)) { + context.encounteredError = true; + } + if (context.tracker.reportInaccessibleThisError) { + context.tracker.reportInaccessibleThisError(); + } + } + context.approximateLength += 4; + return ts.createThis(); + } + if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) { + var typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context); + if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32)) + return ts.createTypeReferenceNode(ts.createIdentifier(""), typeArgumentNodes); + return symbolToTypeNode(type.aliasSymbol, context, 788968, typeArgumentNodes); + } + var objectFlags = ts.getObjectFlags(type); + if (objectFlags & 4) { + ts.Debug.assert(!!(type.flags & 524288)); + return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type); + } + if (type.flags & 262144 || objectFlags & 3) { + if (type.flags & 262144 && ts.contains(context.inferTypeParameters, type)) { + context.approximateLength += (ts.symbolName(type.symbol).length + 6); + return ts.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, undefined)); + } + if (context.flags & 4 && + type.flags & 262144 && + !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + var name = typeParameterToName(type, context); + context.approximateLength += ts.idText(name).length; + return ts.createTypeReferenceNode(ts.createIdentifier(ts.idText(name)), undefined); + } + return type.symbol + ? symbolToTypeNode(type.symbol, context, 788968) + : ts.createTypeReferenceNode(ts.createIdentifier("?"), undefined); + } + if (type.flags & (1048576 | 2097152)) { + var types = type.flags & 1048576 ? formatUnionTypes(type.types) : type.types; + if (ts.length(types) === 1) { + return typeToTypeNodeHelper(types[0], context); + } + var typeNodes = mapToTypeNodes(types, context, true); + if (typeNodes && typeNodes.length > 0) { + var unionOrIntersectionTypeNode = ts.createUnionOrIntersectionTypeNode(type.flags & 1048576 ? 178 : 179, typeNodes); + return unionOrIntersectionTypeNode; + } + else { + if (!context.encounteredError && !(context.flags & 262144)) { + context.encounteredError = true; + } + return undefined; + } + } + if (objectFlags & (16 | 32)) { + ts.Debug.assert(!!(type.flags & 524288)); + return createAnonymousTypeNode(type); + } + if (type.flags & 4194304) { + var indexedType = type.type; + context.approximateLength += 6; + var indexTypeNode = typeToTypeNodeHelper(indexedType, context); + return ts.createTypeOperatorNode(indexTypeNode); + } + if (type.flags & 8388608) { + var objectTypeNode = typeToTypeNodeHelper(type.objectType, context); + var indexTypeNode = typeToTypeNodeHelper(type.indexType, context); + context.approximateLength += 2; + return ts.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode); + } + if (type.flags & 16777216) { + var checkTypeNode = typeToTypeNodeHelper(type.checkType, context); + var saveInferTypeParameters = context.inferTypeParameters; + context.inferTypeParameters = type.root.inferTypeParameters; + var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context); + context.inferTypeParameters = saveInferTypeParameters; + var trueTypeNode = typeToTypeNodeHelper(getTrueTypeFromConditionalType(type), context); + var falseTypeNode = typeToTypeNodeHelper(getFalseTypeFromConditionalType(type), context); + context.approximateLength += 15; + return ts.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode); + } + if (type.flags & 33554432) { + return typeToTypeNodeHelper(type.typeVariable, context); + } + return ts.Debug.fail("Should be unreachable."); + function createMappedTypeNodeFromType(type) { + ts.Debug.assert(!!(type.flags & 524288)); + var readonlyToken = type.declaration.readonlyToken ? ts.createToken(type.declaration.readonlyToken.kind) : undefined; + var questionToken = type.declaration.questionToken ? ts.createToken(type.declaration.questionToken.kind) : undefined; + var appropriateConstraintTypeNode; + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + appropriateConstraintTypeNode = ts.createTypeOperatorNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context)); + } + else { + appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context); + } + var typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type), context, appropriateConstraintTypeNode); + var templateTypeNode = typeToTypeNodeHelper(getTemplateTypeFromMappedType(type), context); + var mappedTypeNode = ts.createMappedTypeNode(readonlyToken, typeParameterNode, questionToken, templateTypeNode); + context.approximateLength += 10; + return ts.setEmitFlags(mappedTypeNode, 1); + } + function createAnonymousTypeNode(type) { + var typeId = "" + type.id; + var symbol = type.symbol; + if (symbol) { + if (isJSConstructor(symbol.valueDeclaration)) { + var isInstanceType = type === getDeclaredTypeOfClassOrInterface(symbol) ? 788968 : 111551; + return symbolToTypeNode(symbol, context, isInstanceType); + } + else if (symbol.flags & 32 && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration.kind === 214 && context.flags & 2048) || + symbol.flags & (384 | 512) || + shouldWriteTypeOfFunctionSymbol()) { + return symbolToTypeNode(symbol, context, 111551); + } + else if (context.visitedTypes && context.visitedTypes.has(typeId)) { + var typeAlias = getTypeAliasForTypeLiteral(type); + if (typeAlias) { + return symbolToTypeNode(typeAlias, context, 788968); + } + else { + return createElidedInformationPlaceholder(context); + } + } + else { + return visitAndTransformType(type, createTypeNodeFromObjectType); + } + } + else { + return createTypeNodeFromObjectType(type); + } + function shouldWriteTypeOfFunctionSymbol() { + var isStaticMethodSymbol = !!(symbol.flags & 8192) && + ts.some(symbol.declarations, function (declaration) { return ts.hasModifier(declaration, 32); }); + var isNonLocalFunctionSymbol = !!(symbol.flags & 16) && + (symbol.parent || + ts.forEach(symbol.declarations, function (declaration) { + return declaration.parent.kind === 290 || declaration.parent.kind === 250; + })); + if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { + return (!!(context.flags & 4096) || (context.visitedTypes && context.visitedTypes.has(typeId))) && + (!(context.flags & 8) || isValueSymbolAccessible(symbol, context.enclosingDeclaration)); + } + } + } + function visitAndTransformType(type, transform) { + var typeId = "" + type.id; + var isConstructorObject = ts.getObjectFlags(type) & 16 && type.symbol && type.symbol.flags & 32; + var id = ts.getObjectFlags(type) & 4 && type.node ? "N" + getNodeId(type.node) : + type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) : + undefined; + if (!context.visitedTypes) { + context.visitedTypes = ts.createMap(); + } + if (id && !context.symbolDepth) { + context.symbolDepth = ts.createMap(); + } + var depth; + if (id) { + depth = context.symbolDepth.get(id) || 0; + if (depth > 10) { + return createElidedInformationPlaceholder(context); + } + context.symbolDepth.set(id, depth + 1); + } + context.visitedTypes.set(typeId, true); + var result = transform(type); + context.visitedTypes.delete(typeId); + if (id) { + context.symbolDepth.set(id, depth); + } + return result; + } + function createTypeNodeFromObjectType(type) { + if (isGenericMappedType(type)) { + return createMappedTypeNodeFromType(type); + } + var resolved = resolveStructuredTypeMembers(type); + if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) { + if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { + context.approximateLength += 2; + return ts.setEmitFlags(ts.createTypeLiteralNode(undefined), 1); + } + if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) { + var signature = resolved.callSignatures[0]; + var signatureNode = signatureToSignatureDeclarationHelper(signature, 170, context); + return signatureNode; + } + if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) { + var signature = resolved.constructSignatures[0]; + var signatureNode = signatureToSignatureDeclarationHelper(signature, 171, context); + return signatureNode; + } + } + var savedFlags = context.flags; + context.flags |= 4194304; + var members = createTypeNodesFromResolvedType(resolved); + context.flags = savedFlags; + var typeLiteralNode = ts.createTypeLiteralNode(members); + context.approximateLength += 2; + return ts.setEmitFlags(typeLiteralNode, (context.flags & 1024) ? 0 : 1); + } + function typeReferenceToTypeNode(type) { + var typeArguments = getTypeArguments(type); + if (type.target === globalArrayType || type.target === globalReadonlyArrayType) { + if (context.flags & 2) { + var typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context); + return ts.createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); + } + var elementType = typeToTypeNodeHelper(typeArguments[0], context); + var arrayType = ts.createArrayTypeNode(elementType); + return type.target === globalArrayType ? arrayType : ts.createTypeOperatorNode(138, arrayType); + } + else if (type.target.objectFlags & 8) { + if (typeArguments.length > 0) { + var arity = getTypeReferenceArity(type); + var tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context); + var hasRestElement = type.target.hasRestElement; + if (tupleConstituentNodes) { + for (var i = type.target.minLength; i < Math.min(arity, tupleConstituentNodes.length); i++) { + tupleConstituentNodes[i] = hasRestElement && i === arity - 1 ? + ts.createRestTypeNode(ts.createArrayTypeNode(tupleConstituentNodes[i])) : + ts.createOptionalTypeNode(tupleConstituentNodes[i]); + } + var tupleTypeNode = ts.createTupleTypeNode(tupleConstituentNodes); + return type.target.readonly ? ts.createTypeOperatorNode(138, tupleTypeNode) : tupleTypeNode; + } + } + if (context.encounteredError || (context.flags & 524288)) { + var tupleTypeNode = ts.createTupleTypeNode([]); + return type.target.readonly ? ts.createTypeOperatorNode(138, tupleTypeNode) : tupleTypeNode; + } + context.encounteredError = true; + return undefined; + } + else if (context.flags & 2048 && + type.symbol.valueDeclaration && + ts.isClassLike(type.symbol.valueDeclaration) && + !isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + return createAnonymousTypeNode(type); + } + else { + var outerTypeParameters = type.target.outerTypeParameters; + var i = 0; + var resultType = void 0; + if (outerTypeParameters) { + var length_1 = outerTypeParameters.length; + while (i < length_1) { + var start = i; + var parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]); + do { + i++; + } while (i < length_1 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent); + if (!ts.rangeEquals(outerTypeParameters, typeArguments, start, i)) { + var typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context); + var flags_2 = context.flags; + context.flags |= 16; + var ref = symbolToTypeNode(parent, context, 788968, typeArgumentSlice); + context.flags = flags_2; + resultType = !resultType ? ref : appendReferenceToType(resultType, ref); + } + } + } + var typeArgumentNodes = void 0; + if (typeArguments.length > 0) { + var typeParameterCount = (type.target.typeParameters || ts.emptyArray).length; + typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context); + } + var flags = context.flags; + context.flags |= 16; + var finalRef = symbolToTypeNode(type.symbol, context, 788968, typeArgumentNodes); + context.flags = flags; + return !resultType ? finalRef : appendReferenceToType(resultType, finalRef); + } + } + function appendReferenceToType(root, ref) { + if (ts.isImportTypeNode(root)) { + var innerParams = root.typeArguments; + if (root.qualifier) { + (ts.isIdentifier(root.qualifier) ? root.qualifier : root.qualifier.right).typeArguments = innerParams; + } + root.typeArguments = ref.typeArguments; + var ids = getAccessStack(ref); + for (var _i = 0, ids_1 = ids; _i < ids_1.length; _i++) { + var id = ids_1[_i]; + root.qualifier = root.qualifier ? ts.createQualifiedName(root.qualifier, id) : id; + } + return root; + } + else { + var innerParams = root.typeArguments; + (ts.isIdentifier(root.typeName) ? root.typeName : root.typeName.right).typeArguments = innerParams; + root.typeArguments = ref.typeArguments; + var ids = getAccessStack(ref); + for (var _a = 0, ids_2 = ids; _a < ids_2.length; _a++) { + var id = ids_2[_a]; + root.typeName = ts.createQualifiedName(root.typeName, id); + } + return root; + } + } + function getAccessStack(ref) { + var state = ref.typeName; + var ids = []; + while (!ts.isIdentifier(state)) { + ids.unshift(state.right); + state = state.left; + } + ids.unshift(state); + return ids; + } + function createTypeNodesFromResolvedType(resolvedType) { + if (checkTruncationLength(context)) { + return [ts.createPropertySignature(undefined, "...", undefined, undefined, undefined)]; + } + var typeElements = []; + for (var _i = 0, _a = resolvedType.callSignatures; _i < _a.length; _i++) { + var signature = _a[_i]; + typeElements.push(signatureToSignatureDeclarationHelper(signature, 165, context)); + } + for (var _b = 0, _c = resolvedType.constructSignatures; _b < _c.length; _b++) { + var signature = _c[_b]; + typeElements.push(signatureToSignatureDeclarationHelper(signature, 166, context)); + } + if (resolvedType.stringIndexInfo) { + var indexSignature = void 0; + if (resolvedType.objectFlags & 2048) { + indexSignature = indexInfoToIndexSignatureDeclarationHelper(createIndexInfo(anyType, resolvedType.stringIndexInfo.isReadonly, resolvedType.stringIndexInfo.declaration), 0, context); + indexSignature.type = createElidedInformationPlaceholder(context); + } + else { + indexSignature = indexInfoToIndexSignatureDeclarationHelper(resolvedType.stringIndexInfo, 0, context); + } + typeElements.push(indexSignature); + } + if (resolvedType.numberIndexInfo) { + typeElements.push(indexInfoToIndexSignatureDeclarationHelper(resolvedType.numberIndexInfo, 1, context)); + } + var properties = resolvedType.properties; + if (!properties) { + return typeElements; + } + var i = 0; + for (var _d = 0, properties_1 = properties; _d < properties_1.length; _d++) { + var propertySymbol = properties_1[_d]; + i++; + if (context.flags & 2048) { + if (propertySymbol.flags & 4194304) { + continue; + } + if (ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 | 16) && context.tracker.reportPrivateInBaseOfClassExpression) { + context.tracker.reportPrivateInBaseOfClassExpression(ts.unescapeLeadingUnderscores(propertySymbol.escapedName)); + } + } + if (checkTruncationLength(context) && (i + 2 < properties.length - 1)) { + typeElements.push(ts.createPropertySignature(undefined, "... " + (properties.length - i) + " more ...", undefined, undefined, undefined)); + addPropertyToElementList(properties[properties.length - 1], context, typeElements); + break; + } + addPropertyToElementList(propertySymbol, context, typeElements); + } + return typeElements.length ? typeElements : undefined; + } + } + function createElidedInformationPlaceholder(context) { + context.approximateLength += 3; + if (!(context.flags & 1)) { + return ts.createTypeReferenceNode(ts.createIdentifier("..."), undefined); + } + return ts.createKeywordTypeNode(125); + } + function addPropertyToElementList(propertySymbol, context, typeElements) { + var propertyIsReverseMapped = !!(ts.getCheckFlags(propertySymbol) & 8192); + var propertyType = propertyIsReverseMapped && context.flags & 33554432 ? + anyType : getTypeOfSymbol(propertySymbol); + var saveEnclosingDeclaration = context.enclosingDeclaration; + context.enclosingDeclaration = undefined; + if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096) { + var decl = ts.first(propertySymbol.declarations); + if (hasLateBindableName(decl)) { + if (ts.isBinaryExpression(decl)) { + var name = ts.getNameOfDeclaration(decl); + if (name && ts.isElementAccessExpression(name) && ts.isPropertyAccessEntityNameExpression(name.argumentExpression)) { + trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context); + } + } + else { + trackComputedName(decl.name.expression, saveEnclosingDeclaration, context); + } + } + } + context.enclosingDeclaration = saveEnclosingDeclaration; + var propertyName = getPropertyNameNodeForSymbol(propertySymbol, context); + context.approximateLength += (ts.symbolName(propertySymbol).length + 1); + var optionalToken = propertySymbol.flags & 16777216 ? ts.createToken(57) : undefined; + if (propertySymbol.flags & (16 | 8192) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) { + var signatures = getSignaturesOfType(filterType(propertyType, function (t) { return !(t.flags & 32768); }), 0); + for (var _i = 0, signatures_1 = signatures; _i < signatures_1.length; _i++) { + var signature = signatures_1[_i]; + var methodDeclaration = signatureToSignatureDeclarationHelper(signature, 160, context); + methodDeclaration.name = propertyName; + methodDeclaration.questionToken = optionalToken; + typeElements.push(preserveCommentsOn(methodDeclaration)); + } + } + else { + var savedFlags = context.flags; + context.flags |= propertyIsReverseMapped ? 33554432 : 0; + var propertyTypeNode = void 0; + if (propertyIsReverseMapped && !!(savedFlags & 33554432)) { + propertyTypeNode = createElidedInformationPlaceholder(context); + } + else { + propertyTypeNode = propertyType ? typeToTypeNodeHelper(propertyType, context) : ts.createKeywordTypeNode(125); + } + context.flags = savedFlags; + var modifiers = isReadonlySymbol(propertySymbol) ? [ts.createToken(138)] : undefined; + if (modifiers) { + context.approximateLength += 9; + } + var propertySignature = ts.createPropertySignature(modifiers, propertyName, optionalToken, propertyTypeNode, undefined); + typeElements.push(preserveCommentsOn(propertySignature)); + } + function preserveCommentsOn(node) { + if (ts.some(propertySymbol.declarations, function (d) { return d.kind === 322; })) { + var d = ts.find(propertySymbol.declarations, function (d) { return d.kind === 322; }); + var commentText = d.comment; + if (commentText) { + ts.setSyntheticLeadingComments(node, [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]); + } + } + else if (propertySymbol.valueDeclaration) { + ts.setCommentRange(node, propertySymbol.valueDeclaration); + } + return node; + } + } + function mapToTypeNodes(types, context, isBareList) { + if (ts.some(types)) { + if (checkTruncationLength(context)) { + if (!isBareList) { + return [ts.createTypeReferenceNode("...", undefined)]; + } + else if (types.length > 2) { + return [ + typeToTypeNodeHelper(types[0], context), + ts.createTypeReferenceNode("... " + (types.length - 2) + " more ...", undefined), + typeToTypeNodeHelper(types[types.length - 1], context) + ]; + } + } + var result = []; + var i = 0; + for (var _i = 0, types_1 = types; _i < types_1.length; _i++) { + var type = types_1[_i]; + i++; + if (checkTruncationLength(context) && (i + 2 < types.length - 1)) { + result.push(ts.createTypeReferenceNode("... " + (types.length - i) + " more ...", undefined)); + var typeNode_1 = typeToTypeNodeHelper(types[types.length - 1], context); + if (typeNode_1) { + result.push(typeNode_1); + } + break; + } + context.approximateLength += 2; + var typeNode = typeToTypeNodeHelper(type, context); + if (typeNode) { + result.push(typeNode); + } + } + return result; + } + } + function indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context) { + var name = ts.getNameFromIndexInfo(indexInfo) || "x"; + var indexerTypeNode = ts.createKeywordTypeNode(kind === 0 ? 143 : 140); + var indexingParameter = ts.createParameter(undefined, undefined, undefined, name, undefined, indexerTypeNode, undefined); + var typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context); + if (!indexInfo.type && !(context.flags & 2097152)) { + context.encounteredError = true; + } + context.approximateLength += (name.length + 4); + return ts.createIndexSignature(undefined, indexInfo.isReadonly ? [ts.createToken(138)] : undefined, [indexingParameter], typeNode); + } + function signatureToSignatureDeclarationHelper(signature, kind, context) { + var suppressAny = context.flags & 256; + if (suppressAny) + context.flags &= ~256; + var typeParameters; + var typeArguments; + if (context.flags & 32 && signature.target && signature.mapper && signature.target.typeParameters) { + typeArguments = signature.target.typeParameters.map(function (parameter) { return typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context); }); + } + else { + typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return typeParameterToDeclaration(parameter, context); }); + } + var parameters = getExpandedParameters(signature).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 162); }); + if (signature.thisParameter) { + var thisParameter = symbolToParameterDeclaration(signature.thisParameter, context); + parameters.unshift(thisParameter); + } + var returnTypeNode; + var typePredicate = getTypePredicateOfSignature(signature); + if (typePredicate) { + var assertsModifier = typePredicate.kind === 2 || typePredicate.kind === 3 ? + ts.createToken(124) : + undefined; + var parameterName = typePredicate.kind === 1 || typePredicate.kind === 3 ? + ts.setEmitFlags(ts.createIdentifier(typePredicate.parameterName), 16777216) : + ts.createThisTypeNode(); + var typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context); + returnTypeNode = ts.createTypePredicateNodeWithModifier(assertsModifier, parameterName, typeNode); + } + else { + var returnType = getReturnTypeOfSignature(signature); + if (returnType && !(suppressAny && isTypeAny(returnType))) { + returnTypeNode = typeToTypeNodeHelper(returnType, context); + } + else if (!suppressAny) { + returnTypeNode = ts.createKeywordTypeNode(125); + } + } + context.approximateLength += 3; + return ts.createSignatureDeclaration(kind, typeParameters, parameters, returnTypeNode, typeArguments); + } + function typeParameterToDeclarationWithConstraint(type, context, constraintNode) { + var savedContextFlags = context.flags; + context.flags &= ~512; + var name = typeParameterToName(type, context); + var defaultParameter = getDefaultFromTypeParameter(type); + var defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context); + context.flags = savedContextFlags; + return ts.createTypeParameterDeclaration(name, constraintNode, defaultParameterNode); + } + function typeParameterToDeclaration(type, context, constraint) { + if (constraint === void 0) { constraint = getConstraintOfTypeParameter(type); } + var constraintNode = constraint && typeToTypeNodeHelper(constraint, context); + return typeParameterToDeclarationWithConstraint(type, context, constraintNode); + } + function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) { + var parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 156); + if (!parameterDeclaration && !ts.isTransientSymbol(parameterSymbol)) { + parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 316); + } + var parameterType = getTypeOfSymbol(parameterSymbol); + if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) { + parameterType = getOptionalType(parameterType); + } + var parameterTypeNode = typeToTypeNodeHelper(parameterType, context); + var modifiers = !(context.flags & 8192) && preserveModifierFlags && parameterDeclaration && parameterDeclaration.modifiers ? parameterDeclaration.modifiers.map(ts.getSynthesizedClone) : undefined; + var isRest = parameterDeclaration && ts.isRestParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 32768; + var dotDotDotToken = isRest ? ts.createToken(25) : undefined; + var name = parameterDeclaration ? parameterDeclaration.name ? + parameterDeclaration.name.kind === 75 ? ts.setEmitFlags(ts.getSynthesizedClone(parameterDeclaration.name), 16777216) : + parameterDeclaration.name.kind === 153 ? ts.setEmitFlags(ts.getSynthesizedClone(parameterDeclaration.name.right), 16777216) : + cloneBindingName(parameterDeclaration.name) : + ts.symbolName(parameterSymbol) : + ts.symbolName(parameterSymbol); + var isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 16384; + var questionToken = isOptional ? ts.createToken(57) : undefined; + var parameterNode = ts.createParameter(undefined, modifiers, dotDotDotToken, name, questionToken, parameterTypeNode, undefined); + context.approximateLength += ts.symbolName(parameterSymbol).length + 3; + return parameterNode; + function cloneBindingName(node) { + return elideInitializerAndSetEmitFlags(node); + function elideInitializerAndSetEmitFlags(node) { + if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) { + trackComputedName(node.expression, context.enclosingDeclaration, context); + } + var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, undefined, elideInitializerAndSetEmitFlags); + var clone = ts.nodeIsSynthesized(visited) ? visited : ts.getSynthesizedClone(visited); + if (clone.kind === 191) { + clone.initializer = undefined; + } + return ts.setEmitFlags(clone, 1 | 16777216); + } + } + } + function trackComputedName(accessExpression, enclosingDeclaration, context) { + if (!context.tracker.trackSymbol) + return; + var firstIdentifier = ts.getFirstIdentifier(accessExpression); + var name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 | 1048576, undefined, undefined, true); + if (name) { + context.tracker.trackSymbol(name, enclosingDeclaration, 111551); + } + } + function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) { + context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning); + return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol); + } + function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) { + var chain; + var isTypeParameter = symbol.flags & 262144; + if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64) && !(context.flags & 134217728)) { + chain = ts.Debug.assertDefined(getSymbolChain(symbol, meaning, true)); + ts.Debug.assert(chain && chain.length > 0); + } + else { + chain = [symbol]; + } + return chain; + function getSymbolChain(symbol, meaning, endOfChain) { + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, !!(context.flags & 128)); + var parentSpecifiers; + if (!accessibleSymbolChain || + needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) { + var parents_1 = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol, context.enclosingDeclaration); + if (ts.length(parents_1)) { + parentSpecifiers = parents_1.map(function (symbol) { + return ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol) + ? getSpecifierForModuleSymbol(symbol, context) + : undefined; + }); + var indices = parents_1.map(function (_, i) { return i; }); + indices.sort(sortByBestName); + var sortedParents = indices.map(function (i) { return parents_1[i]; }); + for (var _i = 0, sortedParents_1 = sortedParents; _i < sortedParents_1.length; _i++) { + var parent = sortedParents_1[_i]; + var parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), false); + if (parentChain) { + if (parent.exports && parent.exports.get("export=") && + getSymbolIfSameReference(parent.exports.get("export="), symbol)) { + accessibleSymbolChain = parentChain; + break; + } + accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol) || symbol]); + break; + } + } + } + } + if (accessibleSymbolChain) { + return accessibleSymbolChain; + } + if (endOfChain || + !(symbol.flags & (2048 | 4096))) { + if (!endOfChain && !yieldModuleSymbol && !!ts.forEach(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + return; + } + return [symbol]; + } + function sortByBestName(a, b) { + var specifierA = parentSpecifiers[a]; + var specifierB = parentSpecifiers[b]; + if (specifierA && specifierB) { + var isBRelative = ts.pathIsRelative(specifierB); + if (ts.pathIsRelative(specifierA) === isBRelative) { + return ts.moduleSpecifiers.countPathComponents(specifierA) - ts.moduleSpecifiers.countPathComponents(specifierB); + } + if (isBRelative) { + return -1; + } + return 1; + } + return 0; + } + } + } + function typeParametersToTypeParameterDeclarations(symbol, context) { + var typeParameterNodes; + var targetSymbol = getTargetSymbol(symbol); + if (targetSymbol.flags & (32 | 64 | 524288)) { + typeParameterNodes = ts.createNodeArray(ts.map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), function (tp) { return typeParameterToDeclaration(tp, context); })); + } + return typeParameterNodes; + } + function lookupTypeParameterNodes(chain, index, context) { + ts.Debug.assert(chain && 0 <= index && index < chain.length); + var symbol = chain[index]; + var symbolId = "" + getSymbolId(symbol); + if (context.typeParameterSymbolList && context.typeParameterSymbolList.get(symbolId)) { + return undefined; + } + (context.typeParameterSymbolList || (context.typeParameterSymbolList = ts.createMap())).set(symbolId, true); + var typeParameterNodes; + if (context.flags & 512 && index < (chain.length - 1)) { + var parentSymbol = symbol; + var nextSymbol = chain[index + 1]; + if (ts.getCheckFlags(nextSymbol) & 1) { + var params = getTypeParametersOfClassOrInterface(parentSymbol.flags & 2097152 ? resolveAlias(parentSymbol) : parentSymbol); + typeParameterNodes = mapToTypeNodes(ts.map(params, nextSymbol.mapper), context); + } + else { + typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context); + } + } + return typeParameterNodes; + } + function getTopmostIndexedAccessType(top) { + if (ts.isIndexedAccessTypeNode(top.objectType)) { + return getTopmostIndexedAccessType(top.objectType); + } + return top; + } + function getSpecifierForModuleSymbol(symbol, context) { + var file = ts.getDeclarationOfKind(symbol, 290); + if (file && file.moduleName !== undefined) { + return file.moduleName; + } + if (!file) { + if (context.tracker.trackReferencedAmbientModule) { + var ambientDecls = ts.filter(symbol.declarations, ts.isAmbientModule); + if (ts.length(ambientDecls)) { + for (var _i = 0, ambientDecls_1 = ambientDecls; _i < ambientDecls_1.length; _i++) { + var decl = ambientDecls_1[_i]; + context.tracker.trackReferencedAmbientModule(decl, symbol); + } + } + } + if (ambientModuleSymbolRegex.test(symbol.escapedName)) { + return symbol.escapedName.substring(1, symbol.escapedName.length - 1); + } + } + if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) { + if (ambientModuleSymbolRegex.test(symbol.escapedName)) { + return symbol.escapedName.substring(1, symbol.escapedName.length - 1); + } + return ts.getSourceFileOfNode(ts.getNonAugmentationDeclaration(symbol)).fileName; + } + var contextFile = ts.getSourceFileOfNode(ts.getOriginalNode(context.enclosingDeclaration)); + var links = getSymbolLinks(symbol); + var specifier = links.specifierCache && links.specifierCache.get(contextFile.path); + if (!specifier) { + var isBundle_1 = (compilerOptions.out || compilerOptions.outFile); + var moduleResolverHost = context.tracker.moduleResolverHost; + var specifierCompilerOptions = isBundle_1 ? __assign(__assign({}, compilerOptions), { baseUrl: moduleResolverHost.getCommonSourceDirectory() }) : compilerOptions; + specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, specifierCompilerOptions, contextFile, moduleResolverHost, host.getSourceFiles(), { importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "relative" }, host.redirectTargetsMap)); + links.specifierCache = links.specifierCache || ts.createMap(); + links.specifierCache.set(contextFile.path, specifier); + } + return specifier; + } + function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) { + var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384)); + var isTypeOf = meaning === 111551; + if (ts.some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + var nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined; + var typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context); + var specifier = getSpecifierForModuleSymbol(chain[0], context); + if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && specifier.indexOf("/node_modules/") >= 0) { + context.encounteredError = true; + if (context.tracker.reportLikelyUnsafeImportRequiredError) { + context.tracker.reportLikelyUnsafeImportRequiredError(specifier); + } + } + var lit = ts.createLiteralTypeNode(ts.createLiteral(specifier)); + if (context.tracker.trackExternalModuleSymbolOfImportTypeNode) + context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]); + context.approximateLength += specifier.length + 10; + if (!nonRootParts || ts.isEntityName(nonRootParts)) { + if (nonRootParts) { + var lastId = ts.isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right; + lastId.typeArguments = undefined; + } + return ts.createImportTypeNode(lit, nonRootParts, typeParameterNodes, isTypeOf); + } + else { + var splitNode = getTopmostIndexedAccessType(nonRootParts); + var qualifier = splitNode.objectType.typeName; + return ts.createIndexedAccessTypeNode(ts.createImportTypeNode(lit, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType); + } + } + var entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0); + if (ts.isIndexedAccessTypeNode(entityName)) { + return entityName; + } + if (isTypeOf) { + return ts.createTypeQueryNode(entityName); + } + else { + var lastId = ts.isIdentifier(entityName) ? entityName : entityName.right; + var lastTypeArgs = lastId.typeArguments; + lastId.typeArguments = undefined; + return ts.createTypeReferenceNode(entityName, lastTypeArgs); + } + function createAccessFromSymbolChain(chain, index, stopper) { + var typeParameterNodes = index === (chain.length - 1) ? overrideTypeArguments : lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + var parent = chain[index - 1]; + var symbolName; + if (index === 0) { + context.flags |= 16777216; + symbolName = getNameOfSymbolAsWritten(symbol, context); + context.approximateLength += (symbolName ? symbolName.length : 0) + 1; + context.flags ^= 16777216; + } + else { + if (parent && getExportsOfSymbol(parent)) { + var exports_1 = getExportsOfSymbol(parent); + ts.forEachEntry(exports_1, function (ex, name) { + if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=") { + symbolName = ts.unescapeLeadingUnderscores(name); + return true; + } + }); + } + } + if (!symbolName) { + symbolName = getNameOfSymbolAsWritten(symbol, context); + } + context.approximateLength += symbolName.length + 1; + if (!(context.flags & 16) && parent && + getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol.escapedName) && + getSymbolIfSameReference(getMembersOfSymbol(parent).get(symbol.escapedName), symbol)) { + var LHS = createAccessFromSymbolChain(chain, index - 1, stopper); + if (ts.isIndexedAccessTypeNode(LHS)) { + return ts.createIndexedAccessTypeNode(LHS, ts.createLiteralTypeNode(ts.createLiteral(symbolName))); + } + else { + return ts.createIndexedAccessTypeNode(ts.createTypeReferenceNode(LHS, typeParameterNodes), ts.createLiteralTypeNode(ts.createLiteral(symbolName))); + } + } + var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216); + identifier.symbol = symbol; + if (index > stopper) { + var LHS = createAccessFromSymbolChain(chain, index - 1, stopper); + if (!ts.isEntityName(LHS)) { + return ts.Debug.fail("Impossible construct - an export of an indexed access cannot be reachable"); + } + return ts.createQualifiedName(LHS, identifier); + } + return identifier; + } + } + function typeParameterShadowsNameInScope(escapedName, context) { + return !!resolveName(context.enclosingDeclaration, escapedName, 788968, undefined, escapedName, false); + } + function typeParameterToName(type, context) { + if (context.flags & 4 && context.typeParameterNames) { + var cached = context.typeParameterNames.get("" + getTypeId(type)); + if (cached) { + return cached; + } + } + var result = symbolToName(type.symbol, context, 788968, true); + if (!(result.kind & 75)) { + return ts.createIdentifier("(Missing type parameter)"); + } + if (context.flags & 4) { + var rawtext = result.escapedText; + var i = 0; + var text = rawtext; + while ((context.typeParameterNamesByText && context.typeParameterNamesByText.get(text)) || typeParameterShadowsNameInScope(text, context)) { + i++; + text = rawtext + "_" + i; + } + if (text !== rawtext) { + result = ts.createIdentifier(text, result.typeArguments); + } + (context.typeParameterNames || (context.typeParameterNames = ts.createMap())).set("" + getTypeId(type), result); + (context.typeParameterNamesByText || (context.typeParameterNamesByText = ts.createMap())).set(result.escapedText, true); + } + return result; + } + function symbolToName(symbol, context, meaning, expectsIdentifier) { + var chain = lookupSymbolChain(symbol, context, meaning); + if (expectsIdentifier && chain.length !== 1 + && !context.encounteredError + && !(context.flags & 65536)) { + context.encounteredError = true; + } + return createEntityNameFromSymbolChain(chain, chain.length - 1); + function createEntityNameFromSymbolChain(chain, index) { + var typeParameterNodes = lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + if (index === 0) { + context.flags |= 16777216; + } + var symbolName = getNameOfSymbolAsWritten(symbol, context); + if (index === 0) { + context.flags ^= 16777216; + } + var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216); + identifier.symbol = symbol; + return index > 0 ? ts.createQualifiedName(createEntityNameFromSymbolChain(chain, index - 1), identifier) : identifier; + } + } + function symbolToExpression(symbol, context, meaning) { + var chain = lookupSymbolChain(symbol, context, meaning); + return createExpressionFromSymbolChain(chain, chain.length - 1); + function createExpressionFromSymbolChain(chain, index) { + var typeParameterNodes = lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + if (index === 0) { + context.flags |= 16777216; + } + var symbolName = getNameOfSymbolAsWritten(symbol, context); + if (index === 0) { + context.flags ^= 16777216; + } + var firstChar = symbolName.charCodeAt(0); + if (ts.isSingleOrDoubleQuote(firstChar) && ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + return ts.createLiteral(getSpecifierForModuleSymbol(symbol, context)); + } + var canUsePropertyAccess = firstChar === 35 ? + symbolName.length > 1 && ts.isIdentifierStart(symbolName.charCodeAt(1), languageVersion) : + ts.isIdentifierStart(firstChar, languageVersion); + if (index === 0 || canUsePropertyAccess) { + var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216); + identifier.symbol = symbol; + return index > 0 ? ts.createPropertyAccess(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier; + } + else { + if (firstChar === 91) { + symbolName = symbolName.substring(1, symbolName.length - 1); + firstChar = symbolName.charCodeAt(0); + } + var expression = void 0; + if (ts.isSingleOrDoubleQuote(firstChar)) { + expression = ts.createLiteral(symbolName.substring(1, symbolName.length - 1).replace(/\\./g, function (s) { return s.substring(1); })); + expression.singleQuote = firstChar === 39; + } + else if (("" + +symbolName) === symbolName) { + expression = ts.createLiteral(+symbolName); + } + if (!expression) { + expression = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216); + expression.symbol = symbol; + } + return ts.createElementAccess(createExpressionFromSymbolChain(chain, index - 1), expression); + } + } + } + function isSingleQuotedStringNamed(d) { + var name = ts.getNameOfDeclaration(d); + if (name && ts.isStringLiteral(name) && (name.singleQuote || + (!ts.nodeIsSynthesized(name) && ts.startsWith(ts.getTextOfNode(name, false), "'")))) { + return true; + } + return false; + } + function getPropertyNameNodeForSymbol(symbol, context) { + var singleQuote = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isSingleQuotedStringNamed); + var fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote); + if (fromNameType) { + return fromNameType; + } + if (ts.isKnownSymbol(symbol)) { + return ts.createComputedPropertyName(ts.createPropertyAccess(ts.createIdentifier("Symbol"), symbol.escapedName.substr(3))); + } + var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName); + return createPropertyNameNodeForIdentifierOrLiteral(rawName, singleQuote); + } + function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType) { + if (nameType.flags & 384) { + var name = "" + nameType.value; + if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) { + return ts.createLiteral(name, !!singleQuote); + } + if (isNumericLiteralName(name) && ts.startsWith(name, "-")) { + return ts.createComputedPropertyName(ts.createLiteral(+name)); + } + return createPropertyNameNodeForIdentifierOrLiteral(name); + } + if (nameType.flags & 8192) { + return ts.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551)); + } + } + } + function createPropertyNameNodeForIdentifierOrLiteral(name, singleQuote) { + return ts.isIdentifierText(name, compilerOptions.target) ? ts.createIdentifier(name) : ts.createLiteral(isNumericLiteralName(name) ? +name : name, !!singleQuote); + } + function cloneNodeBuilderContext(context) { + var initial = __assign({}, context); + if (initial.typeParameterNames) { + initial.typeParameterNames = ts.cloneMap(initial.typeParameterNames); + } + if (initial.typeParameterNamesByText) { + initial.typeParameterNamesByText = ts.cloneMap(initial.typeParameterNamesByText); + } + if (initial.typeParameterSymbolList) { + initial.typeParameterSymbolList = ts.cloneMap(initial.typeParameterSymbolList); + } + return initial; + } + function symbolTableToDeclarationStatements(symbolTable, context, bundled) { + var serializePropertySymbolForClass = makeSerializePropertySymbol(ts.createProperty, 161, true); + var serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol(function (_decorators, mods, name, question, type, initializer) { return ts.createPropertySignature(mods, name, question, type, initializer); }, 160, false); + var enclosingDeclaration = context.enclosingDeclaration; + var results = []; + var visitedSymbols = ts.createMap(); + var deferredPrivates; + var oldcontext = context; + context = __assign(__assign({}, oldcontext), { usedSymbolNames: ts.createMap(), remappedSymbolNames: ts.createMap(), tracker: __assign(__assign({}, oldcontext.tracker), { trackSymbol: function (sym, decl, meaning) { + var accessibleResult = isSymbolAccessible(sym, decl, meaning, false); + if (accessibleResult.accessibility === 0) { + var chain = lookupSymbolChainWorker(sym, context, meaning); + if (!(sym.flags & 4)) { + includePrivateSymbol(chain[0]); + } + } + else if (oldcontext.tracker && oldcontext.tracker.trackSymbol) { + oldcontext.tracker.trackSymbol(sym, decl, meaning); + } + } }) }); + if (oldcontext.usedSymbolNames) { + oldcontext.usedSymbolNames.forEach(function (_, name) { + context.usedSymbolNames.set(name, true); + }); + } + ts.forEachEntry(symbolTable, function (symbol, name) { + var baseName = ts.unescapeLeadingUnderscores(name); + void getInternalSymbolName(symbol, baseName); + }); + var addingDeclare = !bundled; + var exportEquals = symbolTable.get("export="); + if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152) { + symbolTable = ts.createSymbolTable(); + symbolTable.set("export=", exportEquals); + } + visitSymbolTable(symbolTable); + return mergeRedundantStatements(results); + function isIdentifierAndNotUndefined(node) { + return !!node && node.kind === 75; + } + function getNamesOfDeclaration(statement) { + if (ts.isVariableStatement(statement)) { + return ts.filter(ts.map(statement.declarationList.declarations, ts.getNameOfDeclaration), isIdentifierAndNotUndefined); + } + return ts.filter([ts.getNameOfDeclaration(statement)], isIdentifierAndNotUndefined); + } + function flattenExportAssignedNamespace(statements) { + var exportAssignment = ts.find(statements, ts.isExportAssignment); + var ns = ts.find(statements, ts.isModuleDeclaration); + if (ns && exportAssignment && exportAssignment.isExportEquals && + ts.isIdentifier(exportAssignment.expression) && ts.isIdentifier(ns.name) && ts.idText(ns.name) === ts.idText(exportAssignment.expression) && + ns.body && ts.isModuleBlock(ns.body)) { + var excessExports = ts.filter(statements, function (s) { return !!(ts.getModifierFlags(s) & 1); }); + if (ts.length(excessExports)) { + ns.body.statements = ts.createNodeArray(__spreadArrays(ns.body.statements, [ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.createExportSpecifier(undefined, id); })), undefined)])); + } + if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, ns.name); })) { + results = []; + ts.forEach(ns.body.statements, function (s) { + addResult(s, 0); + }); + statements = __spreadArrays(ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; }), results); + } + } + return statements; + } + function mergeExportDeclarations(statements) { + var exports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); }); + if (ts.length(exports) > 1) { + var nonExports = ts.filter(statements, function (d) { return !ts.isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause; }); + statements = __spreadArrays(nonExports, [ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.flatMap(exports, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), undefined)]); + } + var reexports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); }); + if (ts.length(reexports) > 1) { + var groups = ts.group(reexports, function (decl) { return ts.isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">"; }); + if (groups.length !== reexports.length) { + var _loop_7 = function (group_1) { + if (group_1.length > 1) { + statements = __spreadArrays(ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; }), [ + ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.flatMap(group_1, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), group_1[0].moduleSpecifier) + ]); + } + }; + for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) { + var group_1 = groups_1[_i]; + _loop_7(group_1); + } + } + } + return statements; + } + function inlineExportModifiers(statements) { + var exportDecl = ts.find(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause; }); + if (exportDecl && exportDecl.exportClause && ts.isNamedExports(exportDecl.exportClause)) { + var replacements = ts.mapDefined(exportDecl.exportClause.elements, function (e) { + if (!e.propertyName) { + var associated = ts.filter(statements, function (s) { return ts.nodeHasName(s, e.name); }); + if (ts.length(associated) && ts.every(associated, canHaveExportModifier)) { + ts.forEach(associated, addExportModifier); + return undefined; + } + } + return e; + }); + if (!ts.length(replacements)) { + statements = ts.filter(statements, function (s) { return s !== exportDecl; }); + } + else { + exportDecl.exportClause.elements = ts.createNodeArray(replacements); + } + } + return statements; + } + function mergeRedundantStatements(statements) { + statements = flattenExportAssignedNamespace(statements); + statements = mergeExportDeclarations(statements); + statements = inlineExportModifiers(statements); + if (enclosingDeclaration && + ((ts.isSourceFile(enclosingDeclaration) && ts.isExternalOrCommonJsModule(enclosingDeclaration)) || ts.isModuleDeclaration(enclosingDeclaration)) && + (!ts.some(statements, ts.isExternalModuleIndicator) || (!ts.hasScopeMarker(statements) && ts.some(statements, ts.needsScopeMarker)))) { + statements.push(ts.createEmptyExports()); + } + return statements; + } + function canHaveExportModifier(node) { + return ts.isEnumDeclaration(node) || + ts.isVariableStatement(node) || + ts.isFunctionDeclaration(node) || + ts.isClassDeclaration(node) || + (ts.isModuleDeclaration(node) && !ts.isExternalModuleAugmentation(node) && !ts.isGlobalScopeAugmentation(node)) || + ts.isInterfaceDeclaration(node) || + isTypeDeclaration(node); + } + function addExportModifier(statement) { + var flags = (ts.getModifierFlags(statement) | 1) & ~2; + statement.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(flags)); + statement.modifierFlagsCache = 0; + } + function visitSymbolTable(symbolTable, suppressNewPrivateContext, propertyAsAlias) { + var oldDeferredPrivates = deferredPrivates; + if (!suppressNewPrivateContext) { + deferredPrivates = ts.createMap(); + } + symbolTable.forEach(function (symbol) { + serializeSymbol(symbol, false, !!propertyAsAlias); + }); + if (!suppressNewPrivateContext) { + deferredPrivates.forEach(function (symbol) { + serializeSymbol(symbol, true, !!propertyAsAlias); + }); + } + deferredPrivates = oldDeferredPrivates; + } + function serializeSymbol(symbol, isPrivate, propertyAsAlias) { + var visitedSym = getMergedSymbol(symbol); + if (visitedSymbols.has("" + getSymbolId(visitedSym))) { + return; + } + visitedSymbols.set("" + getSymbolId(visitedSym), true); + var skipMembershipCheck = !isPrivate; + if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) { + var oldContext = context; + context = cloneNodeBuilderContext(context); + var result = serializeSymbolWorker(symbol, isPrivate, propertyAsAlias); + context = oldContext; + return result; + } + } + function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) { + var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName); + var isDefault = symbol.escapedName === "default"; + if (ts.isStringANonContextualKeyword(symbolName) && !isDefault) { + context.encounteredError = true; + return; + } + var needsPostExportDefault = isDefault && !!(symbol.flags & -113 + || (symbol.flags & 16 && ts.length(getPropertiesOfType(getTypeOfSymbol(symbol))))) && !(symbol.flags & 2097152); + if (needsPostExportDefault) { + isPrivate = true; + } + var modifierFlags = (!isPrivate ? 1 : 0) | (isDefault && !needsPostExportDefault ? 512 : 0); + var isConstMergedWithNS = symbol.flags & 1536 && + symbol.flags & (2 | 1 | 4) && + symbol.escapedName !== "export="; + var isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol); + if (symbol.flags & (16 | 8192) || isConstMergedWithNSPrintableAsSignatureMerge) { + serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + if (symbol.flags & 524288) { + serializeTypeAlias(symbol, symbolName, modifierFlags); + } + if (symbol.flags & (2 | 1 | 4) + && symbol.escapedName !== "export=" + && !(symbol.flags & 4194304) + && !(symbol.flags & 32) + && !isConstMergedWithNSPrintableAsSignatureMerge) { + serializeVariableOrProperty(symbol, symbolName, isPrivate, needsPostExportDefault, propertyAsAlias, modifierFlags); + } + if (symbol.flags & 384) { + serializeEnum(symbol, symbolName, modifierFlags); + } + if (symbol.flags & 32) { + if (symbol.flags & 4) { + serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + else { + serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + } + if ((symbol.flags & (512 | 1024) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol))) || isConstMergedWithNSPrintableAsSignatureMerge) { + serializeModule(symbol, symbolName, modifierFlags); + } + if (symbol.flags & 64) { + serializeInterface(symbol, symbolName, modifierFlags); + } + if (symbol.flags & 2097152) { + serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + if (symbol.flags & 4 && symbol.escapedName === "export=") { + serializeMaybeAliasAssignment(symbol); + } + if (symbol.flags & 8388608) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var node = _a[_i]; + var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier); + if (!resolvedModule) + continue; + addResult(ts.createExportDeclaration(undefined, undefined, undefined, ts.createLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0); + } + } + if (needsPostExportDefault) { + addResult(ts.createExportAssignment(undefined, undefined, false, ts.createIdentifier(getInternalSymbolName(symbol, symbolName))), 0); + } + } + function includePrivateSymbol(symbol) { + if (ts.some(symbol.declarations, ts.isParameterDeclaration)) + return; + ts.Debug.assertDefined(deferredPrivates); + getUnusedName(ts.unescapeLeadingUnderscores(symbol.escapedName), symbol); + deferredPrivates.set("" + getSymbolId(symbol), symbol); + } + function isExportingScope(enclosingDeclaration) { + return ((ts.isSourceFile(enclosingDeclaration) && (ts.isExternalOrCommonJsModule(enclosingDeclaration) || ts.isJsonSourceFile(enclosingDeclaration))) || + (ts.isAmbientModule(enclosingDeclaration) && !ts.isGlobalScopeAugmentation(enclosingDeclaration))); + } + function addResult(node, additionalModifierFlags) { + var newModifierFlags = 0; + if (additionalModifierFlags & 1 && + enclosingDeclaration && + isExportingScope(enclosingDeclaration) && + canHaveExportModifier(node)) { + newModifierFlags |= 1; + } + if (addingDeclare && !(newModifierFlags & 1) && + (!enclosingDeclaration || !(enclosingDeclaration.flags & 8388608)) && + (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) { + newModifierFlags |= 2; + } + if ((additionalModifierFlags & 512) && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node))) { + newModifierFlags |= 512; + } + if (newModifierFlags) { + node.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(newModifierFlags | ts.getModifierFlags(node))); + node.modifierFlagsCache = 0; + } + results.push(node); + } + function serializeTypeAlias(symbol, symbolName, modifierFlags) { + var aliasType = getDeclaredTypeOfTypeAlias(symbol); + var typeParams = getSymbolLinks(symbol).typeParameters; + var typeParamDecls = ts.map(typeParams, function (p) { return typeParameterToDeclaration(p, context); }); + var jsdocAliasDecl = ts.find(symbol.declarations, ts.isJSDocTypeAlias); + var commentText = jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined; + var oldFlags = context.flags; + context.flags |= 8388608; + addResult(ts.setSyntheticLeadingComments(ts.createTypeAliasDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeToTypeNodeHelper(aliasType, context)), !commentText ? [] : [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags); + context.flags = oldFlags; + } + function serializeInterface(symbol, symbolName, modifierFlags) { + var interfaceType = getDeclaredTypeOfClassOrInterface(symbol); + var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); }); + var baseTypes = getBaseTypes(interfaceType); + var baseType = ts.length(baseTypes) ? getIntersectionType(baseTypes) : undefined; + var members = ts.flatMap(getPropertiesOfType(interfaceType), function (p) { return serializePropertySymbolForInterface(p, baseType); }); + var callSignatures = serializeSignatures(0, interfaceType, baseType, 165); + var constructSignatures = serializeSignatures(1, interfaceType, baseType, 166); + var indexSignatures = serializeIndexSignatures(interfaceType, baseType); + var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.createHeritageClause(90, ts.mapDefined(baseTypes, function (b) { return trySerializeAsTypeReference(b); }))]; + addResult(ts.createInterfaceDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, constructSignatures, callSignatures, members)), modifierFlags); + } + function getNamespaceMembersForSerialization(symbol) { + return !symbol.exports ? [] : ts.filter(ts.arrayFrom((symbol.exports).values()), function (p) { return !((p.flags & 4194304) || (p.escapedName === "prototype")); }); + } + function isTypeOnlyNamespace(symbol) { + return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551); }); + } + function serializeModule(symbol, symbolName, modifierFlags) { + var members = getNamespaceMembersForSerialization(symbol); + var locationMap = ts.arrayToMultiMap(members, function (m) { return m.parent && m.parent === symbol ? "real" : "merged"; }); + var realMembers = locationMap.get("real") || ts.emptyArray; + var mergedMembers = locationMap.get("merged") || ts.emptyArray; + if (ts.length(realMembers)) { + var localName = getInternalSymbolName(symbol, symbolName); + serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 | 67108864))); + } + if (ts.length(mergedMembers)) { + var localName = getInternalSymbolName(symbol, symbolName); + var nsBody = ts.createModuleBlock([ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.map(ts.filter(mergedMembers, function (n) { return n.escapedName !== "export="; }), function (s) { + var name = ts.unescapeLeadingUnderscores(s.escapedName); + var localName = getInternalSymbolName(s, name); + var aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s); + var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true); + includePrivateSymbol(target || s); + var targetName = target ? getInternalSymbolName(target, ts.unescapeLeadingUnderscores(target.escapedName)) : localName; + return ts.createExportSpecifier(name === targetName ? undefined : targetName, name); + })))]); + addResult(ts.createModuleDeclaration(undefined, undefined, ts.createIdentifier(localName), nsBody, 16), 0); + } + } + function serializeEnum(symbol, symbolName, modifierFlags) { + addResult(ts.createEnumDeclaration(undefined, ts.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 : 0), getInternalSymbolName(symbol, symbolName), ts.map(ts.filter(getPropertiesOfType(getTypeOfSymbol(symbol)), function (p) { return !!(p.flags & 8); }), function (p) { + var initializedValue = p.declarations && p.declarations[0] && ts.isEnumMember(p.declarations[0]) && getConstantValue(p.declarations[0]); + return ts.createEnumMember(ts.unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined : ts.createLiteral(initializedValue)); + })), modifierFlags); + } + function serializeVariableOrProperty(symbol, symbolName, isPrivate, needsPostExportDefault, propertyAsAlias, modifierFlags) { + if (propertyAsAlias) { + serializeMaybeAliasAssignment(symbol); + } + else { + var type = getTypeOfSymbol(symbol); + var localName = getInternalSymbolName(symbol, symbolName); + if (!(symbol.flags & 16) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) { + serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags); + } + else { + var flags = !(symbol.flags & 2) ? undefined + : isConstVariable(symbol) ? 2 + : 1; + var name = (needsPostExportDefault || !(symbol.flags & 4)) ? localName : getUnusedName(localName, symbol); + var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); }); + if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) { + textRange = textRange.parent.parent; + } + var statement = ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(name, serializeTypeForDeclaration(type, symbol)) + ], flags)), textRange); + addResult(statement, name !== localName ? modifierFlags & ~1 : modifierFlags); + if (name !== localName && !isPrivate) { + addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(name, localName)])), 0); + } + } + } + } + function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) { + var signatures = getSignaturesOfType(type, 0); + for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) { + var sig = signatures_2[_i]; + var decl = signatureToSignatureDeclarationHelper(sig, 244, context); + decl.name = ts.createIdentifier(localName); + addResult(ts.setTextRange(decl, sig.declaration), modifierFlags); + } + if (!(symbol.flags & (512 | 1024) && !!symbol.exports && !!symbol.exports.size)) { + var props = ts.filter(getPropertiesOfType(type), function (p) { return !((p.flags & 4194304) || (p.escapedName === "prototype")); }); + serializeAsNamespaceDeclaration(props, localName, modifierFlags, true); + } + } + function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) { + if (ts.length(props)) { + var localVsRemoteMap = ts.arrayToMultiMap(props, function (p) { + return !ts.length(p.declarations) || ts.some(p.declarations, function (d) { + return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration); + }) ? "local" : "remote"; + }); + var localProps = localVsRemoteMap.get("local") || ts.emptyArray; + var fakespace = ts.createModuleDeclaration(undefined, undefined, ts.createIdentifier(localName), ts.createModuleBlock([]), 16); + fakespace.flags ^= 8; + fakespace.parent = enclosingDeclaration; + fakespace.locals = ts.createSymbolTable(props); + fakespace.symbol = props[0].parent; + var oldResults = results; + results = []; + var oldAddingDeclare = addingDeclare; + addingDeclare = false; + var subcontext = __assign(__assign({}, context), { enclosingDeclaration: fakespace }); + var oldContext = context; + context = subcontext; + visitSymbolTable(ts.createSymbolTable(localProps), suppressNewPrivateContext, true); + context = oldContext; + addingDeclare = oldAddingDeclare; + var declarations = results; + results = oldResults; + fakespace.flags ^= 8; + fakespace.parent = undefined; + fakespace.locals = undefined; + fakespace.symbol = undefined; + fakespace.body = ts.createModuleBlock(declarations); + addResult(fakespace, modifierFlags); + } + } + function serializeAsClass(symbol, localName, modifierFlags) { + var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); }); + var classType = getDeclaredTypeOfClassOrInterface(symbol); + var baseTypes = getBaseTypes(classType); + var staticType = getTypeOfSymbol(symbol); + var staticBaseType = getBaseConstructorTypeOfClass(staticType); + var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.createHeritageClause(90, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))]; + var symbolProps = getPropertiesOfType(classType); + var publicSymbolProps = ts.filter(symbolProps, function (s) { + var valueDecl = s.valueDeclaration; + ts.Debug.assertDefined(valueDecl); + return !(ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name)); + }); + var hasPrivateIdentifier = ts.some(symbolProps, function (s) { + var valueDecl = s.valueDeclaration; + ts.Debug.assertDefined(valueDecl); + return ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name); + }); + var privateProperties = hasPrivateIdentifier ? + [ts.createProperty(undefined, undefined, ts.createPrivateIdentifier("#private"), undefined, undefined, undefined)] : + ts.emptyArray; + var publicProperties = ts.flatMap(publicSymbolProps, function (p) { return serializePropertySymbolForClass(p, false, baseTypes[0]); }); + var staticMembers = symbol.flags & (16 | 512) + ? [] + : ts.flatMap(ts.filter(getPropertiesOfType(staticType), function (p) { return !(p.flags & 4194304) && p.escapedName !== "prototype"; }), function (p) { return serializePropertySymbolForClass(p, true, staticBaseType); }); + var constructors = serializeSignatures(1, staticType, baseTypes[0], 162); + for (var _i = 0, constructors_1 = constructors; _i < constructors_1.length; _i++) { + var c = constructors_1[_i]; + c.type = undefined; + c.typeParameters = undefined; + } + var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]); + addResult(ts.setTextRange(ts.createClassDeclaration(undefined, undefined, localName, typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, staticMembers, constructors, publicProperties, privateProperties)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags); + } + function serializeAsAlias(symbol, localName, modifierFlags) { + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + var target = getMergedSymbol(getTargetOfAliasDeclaration(node, true)); + if (!target) { + return; + } + var verbatimTargetName = ts.unescapeLeadingUnderscores(target.escapedName); + if (verbatimTargetName === "export=" && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) { + verbatimTargetName = "default"; + } + var targetName = getInternalSymbolName(target, verbatimTargetName); + includePrivateSymbol(target); + switch (node.kind) { + case 253: + var isLocalImport = !(target.flags & 512); + addResult(ts.createImportEqualsDeclaration(undefined, undefined, ts.createIdentifier(localName), isLocalImport + ? symbolToName(target, context, 67108863, false) + : ts.createExternalModuleReference(ts.createLiteral(getSpecifierForModuleSymbol(symbol, context)))), isLocalImport ? modifierFlags : 0); + break; + case 252: + addResult(ts.createNamespaceExportDeclaration(ts.idText(node.name)), 0); + break; + case 255: + addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(ts.createIdentifier(localName), undefined), ts.createLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0); + break; + case 256: + addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(ts.createIdentifier(localName))), ts.createLiteral(getSpecifierForModuleSymbol(target, context))), 0); + break; + case 262: + addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamespaceExport(ts.createIdentifier(localName)), ts.createLiteral(getSpecifierForModuleSymbol(target, context))), 0); + break; + case 258: + addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamedImports([ + ts.createImportSpecifier(localName !== verbatimTargetName ? ts.createIdentifier(verbatimTargetName) : undefined, ts.createIdentifier(localName)) + ])), ts.createLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0); + break; + case 263: + var specifier = node.parent.parent.moduleSpecifier; + serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? verbatimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.createLiteral(specifier.text) : undefined); + break; + case 259: + serializeMaybeAliasAssignment(symbol); + break; + case 209: + case 194: + if (symbol.escapedName === "default" || symbol.escapedName === "export=") { + serializeMaybeAliasAssignment(symbol); + } + else { + serializeExportSpecifier(localName, targetName); + } + break; + default: + return ts.Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!"); + } + } + function serializeExportSpecifier(localName, targetName, specifier) { + addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(localName !== targetName ? targetName : undefined, localName)]), specifier), 0); + } + function serializeMaybeAliasAssignment(symbol) { + if (symbol.flags & 4194304) { + return; + } + var name = ts.unescapeLeadingUnderscores(symbol.escapedName); + var isExportEquals = name === "export="; + var isDefault = name === "default"; + var isExportAssignment = isExportEquals || isDefault; + var aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol); + var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true); + if (target && ts.length(target.declarations) && ts.some(target.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(enclosingDeclaration); })) { + var expr = isExportAssignment ? ts.getExportAssignmentExpression(aliasDecl) : ts.getPropertyAssignmentAliasLikeExpression(aliasDecl); + var first_1 = ts.isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : undefined; + var referenced = first_1 && resolveEntityName(first_1, 67108863, true, true, enclosingDeclaration); + if (referenced || target) { + includePrivateSymbol(referenced || target); + } + var oldTrack = context.tracker.trackSymbol; + context.tracker.trackSymbol = ts.noop; + if (isExportAssignment) { + results.push(ts.createExportAssignment(undefined, undefined, isExportEquals, symbolToExpression(target, context, 67108863))); + } + else { + if (first_1 === expr) { + serializeExportSpecifier(name, ts.idText(first_1)); + } + else if (ts.isClassExpression(expr)) { + serializeExportSpecifier(name, getInternalSymbolName(target, ts.symbolName(target))); + } + else { + var varName = getUnusedName(name, symbol); + addResult(ts.createImportEqualsDeclaration(undefined, undefined, ts.createIdentifier(varName), symbolToName(target, context, 67108863, false)), 0); + serializeExportSpecifier(name, varName); + } + } + context.tracker.trackSymbol = oldTrack; + } + else { + var varName = getUnusedName(name, symbol); + var typeToSerialize = getWidenedType(getTypeOfSymbol(symbol)); + if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) { + serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignment ? 0 : 1); + } + else { + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(varName, serializeTypeForDeclaration(typeToSerialize, symbol)) + ], 2)); + addResult(statement, name === varName ? 1 : 0); + } + if (isExportAssignment) { + results.push(ts.createExportAssignment(undefined, undefined, isExportEquals, ts.createIdentifier(varName))); + } + else if (name !== varName) { + serializeExportSpecifier(name, varName); + } + } + } + function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) { + var ctxSrc = ts.getSourceFileOfNode(context.enclosingDeclaration); + return ts.getObjectFlags(typeToSerialize) & (16 | 32) && + !getIndexInfoOfType(typeToSerialize, 0) && + !getIndexInfoOfType(typeToSerialize, 1) && + !!(ts.length(getPropertiesOfType(typeToSerialize)) || ts.length(getSignaturesOfType(typeToSerialize, 0))) && + !ts.length(getSignaturesOfType(typeToSerialize, 1)) && + !getDeclarationWithTypeAnnotation(hostSymbol) && + !(typeToSerialize.symbol && ts.some(typeToSerialize.symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; })) && + !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return isLateBoundName(p.escapedName); }) && + !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return ts.some(p.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; }); }) && + ts.every(getPropertiesOfType(typeToSerialize), function (p) { return ts.isIdentifierText(ts.symbolName(p), languageVersion) && !ts.isStringAKeyword(ts.symbolName(p)); }); + } + function makeSerializePropertySymbol(createProperty, methodKind, useAccessors) { + return function serializePropertySymbol(p, isStatic, baseType) { + var modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(p); + var isPrivate = !!(modifierFlags & 8); + if (isStatic && (p.flags & (788968 | 1920 | 2097152))) { + return []; + } + if (p.flags & 4194304 || (baseType && getPropertyOfType(baseType, p.escapedName) + && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) + && (p.flags & 16777216) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216) + && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)))) { + return []; + } + var flag = (modifierFlags & ~256) | (isStatic ? 32 : 0); + var name = getPropertyNameNodeForSymbol(p, context); + var firstPropertyLikeDecl = ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isAccessor, ts.isVariableDeclaration, ts.isPropertySignature, ts.isBinaryExpression, ts.isPropertyAccessExpression)); + if (p.flags & 98304 && useAccessors) { + var result = []; + if (p.flags & 65536) { + result.push(ts.setTextRange(ts.createSetAccessor(undefined, ts.createModifiersFromModifierFlags(flag), name, [ts.createParameter(undefined, undefined, undefined, "arg", undefined, isPrivate ? undefined : serializeTypeForDeclaration(getTypeOfSymbol(p), p))], undefined), ts.find(p.declarations, ts.isSetAccessor) || firstPropertyLikeDecl)); + } + if (p.flags & 32768) { + var isPrivate_1 = modifierFlags & 8; + result.push(ts.setTextRange(ts.createGetAccessor(undefined, ts.createModifiersFromModifierFlags(flag), name, [], isPrivate_1 ? undefined : serializeTypeForDeclaration(getTypeOfSymbol(p), p), undefined), ts.find(p.declarations, ts.isGetAccessor) || firstPropertyLikeDecl)); + } + return result; + } + else if (p.flags & (4 | 3)) { + return ts.setTextRange(createProperty(undefined, ts.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.createToken(57) : undefined, isPrivate ? undefined : serializeTypeForDeclaration(getTypeOfSymbol(p), p), undefined), ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isVariableDeclaration)) || firstPropertyLikeDecl); + } + if (p.flags & (8192 | 16)) { + var type = getTypeOfSymbol(p); + var signatures = getSignaturesOfType(type, 0); + if (flag & 8) { + return ts.setTextRange(createProperty(undefined, ts.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.createToken(57) : undefined, undefined, undefined), ts.find(p.declarations, ts.isFunctionLikeDeclaration) || signatures[0] && signatures[0].declaration || p.declarations[0]); + } + var results_1 = []; + for (var _i = 0, signatures_3 = signatures; _i < signatures_3.length; _i++) { + var sig = signatures_3[_i]; + var decl = signatureToSignatureDeclarationHelper(sig, methodKind, context); + decl.name = name; + if (flag) { + decl.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(flag)); + } + if (p.flags & 16777216) { + decl.questionToken = ts.createToken(57); + } + results_1.push(ts.setTextRange(decl, sig.declaration)); + } + return results_1; + } + return ts.Debug.fail("Unhandled class member kind! " + (p.__debugFlags || p.flags)); + }; + } + function serializePropertySymbolForInterface(p, baseType) { + return serializePropertySymbolForInterfaceWorker(p, false, baseType); + } + function getDeclarationWithTypeAnnotation(symbol) { + return symbol.declarations && ts.find(symbol.declarations, function (s) { return !!ts.getEffectiveTypeAnnotationNode(s) && !!ts.findAncestor(s, function (n) { return n === enclosingDeclaration; }); }); + } + function serializeTypeForDeclaration(type, symbol) { + var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol); + if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation)) { + var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation); + var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols); + return transformed === existing ? ts.getMutableClone(existing) : transformed; + } + var oldFlags = context.flags; + if (type.flags & 8192 && + type.symbol === symbol) { + context.flags |= 1048576; + } + var result = typeToTypeNodeHelper(type, context); + context.flags = oldFlags; + return result; + function visitExistingNodeTreeSymbols(node) { + if (ts.isJSDocAllType(node)) { + return ts.createKeywordTypeNode(125); + } + if (ts.isJSDocUnknownType(node)) { + return ts.createKeywordTypeNode(148); + } + if (ts.isJSDocNullableType(node)) { + return ts.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.createKeywordTypeNode(100)]); + } + if (ts.isJSDocOptionalType(node)) { + return ts.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.createKeywordTypeNode(146)]); + } + if (ts.isJSDocNonNullableType(node)) { + return ts.visitNode(node.type, visitExistingNodeTreeSymbols); + } + if ((ts.isExpressionWithTypeArguments(node) || ts.isTypeReferenceNode(node)) && ts.isJSDocIndexSignature(node)) { + return ts.createTypeLiteralNode([ts.createIndexSignature(undefined, undefined, [ts.createParameter(undefined, undefined, undefined, "x", undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]); + } + if (ts.isJSDocFunctionType(node)) { + if (ts.isJSDocConstructSignature(node)) { + var newTypeNode_1; + return ts.createConstructorTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.createParameter(undefined, undefined, p.dotDotDotToken, p.name || p.dotDotDotToken ? "args" : "arg" + i, p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols)); + } + else { + return ts.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.createParameter(undefined, undefined, p.dotDotDotToken, p.name || p.dotDotDotToken ? "args" : "arg" + i, p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols)); + } + } + if (ts.isLiteralImportTypeNode(node)) { + return ts.updateImportTypeNode(node, ts.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), node.qualifier, ts.visitNodes(node.typeArguments, visitExistingNodeTreeSymbols, ts.isTypeNode), node.isTypeOf); + } + if (ts.isEntityName(node) || ts.isEntityNameExpression(node)) { + var leftmost = ts.getFirstIdentifier(node); + var sym = resolveEntityName(leftmost, 67108863, true, true); + if (sym) { + includePrivateSymbol(sym); + if (ts.isIdentifier(node) && sym.flags & 262144) { + var name = typeParameterToName(getDeclaredTypeOfSymbol(sym), context); + if (ts.idText(name) !== ts.idText(node)) { + return name; + } + return node; + } + } + } + return ts.visitEachChild(node, visitExistingNodeTreeSymbols, ts.nullTransformationContext); + } + function rewriteModuleSpecifier(parent, lit) { + if (bundled) { + if (context.tracker && context.tracker.moduleResolverHost) { + var targetFile = getExternalModuleFileFromDeclaration(parent); + if (targetFile) { + var getCanonicalFileName = ts.createGetCanonicalFileName(!!host.useCaseSensitiveFileNames); + var resolverHost = { + getCanonicalFileName: getCanonicalFileName, + getCurrentDirectory: context.tracker.moduleResolverHost.getCurrentDirectory ? function () { return context.tracker.moduleResolverHost.getCurrentDirectory(); } : function () { return ""; }, + getCommonSourceDirectory: function () { return context.tracker.moduleResolverHost.getCommonSourceDirectory(); } + }; + var newName = ts.getResolvedExternalModuleName(resolverHost, targetFile); + return ts.createLiteral(newName); + } + } + } + else { + if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) { + var moduleSym = resolveExternalModuleNameWorker(lit, lit, undefined); + if (moduleSym) { + context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym); + } + } + } + return lit; + } + } + function serializeSignatures(kind, input, baseType, outputKind) { + var signatures = getSignaturesOfType(input, kind); + if (kind === 1) { + if (!baseType && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) { + return []; + } + if (baseType) { + var baseSigs = getSignaturesOfType(baseType, 1); + if (!ts.length(baseSigs) && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) { + return []; + } + if (baseSigs.length === signatures.length) { + var failed = false; + for (var i = 0; i < baseSigs.length; i++) { + if (!compareSignaturesIdentical(signatures[i], baseSigs[i], false, false, true, compareTypesIdentical)) { + failed = true; + break; + } + } + if (!failed) { + return []; + } + } + } + var privateProtected = 0; + for (var _i = 0, signatures_4 = signatures; _i < signatures_4.length; _i++) { + var s = signatures_4[_i]; + if (s.declaration) { + privateProtected |= ts.getSelectedModifierFlags(s.declaration, 8 | 16); + } + } + if (privateProtected) { + return [ts.setTextRange(ts.createConstructor(undefined, ts.createModifiersFromModifierFlags(privateProtected), [], undefined), signatures[0].declaration)]; + } + } + var results = []; + for (var _a = 0, signatures_5 = signatures; _a < signatures_5.length; _a++) { + var sig = signatures_5[_a]; + var decl = signatureToSignatureDeclarationHelper(sig, outputKind, context); + results.push(ts.setTextRange(decl, sig.declaration)); + } + return results; + } + function serializeIndexSignatures(input, baseType) { + var results = []; + for (var _i = 0, _a = [0, 1]; _i < _a.length; _i++) { + var type = _a[_i]; + var info = getIndexInfoOfType(input, type); + if (info) { + if (baseType) { + var baseInfo = getIndexInfoOfType(baseType, type); + if (baseInfo) { + if (isTypeIdenticalTo(info.type, baseInfo.type)) { + continue; + } + } + } + results.push(indexInfoToIndexSignatureDeclarationHelper(info, type, context)); + } + } + return results; + } + function serializeBaseType(t, staticType, rootName) { + var ref = trySerializeAsTypeReference(t); + if (ref) { + return ref; + } + var tempName = getUnusedName(rootName + "_base"); + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(tempName, typeToTypeNodeHelper(staticType, context)) + ], 2)); + addResult(statement, 0); + return ts.createExpressionWithTypeArguments(undefined, ts.createIdentifier(tempName)); + } + function trySerializeAsTypeReference(t) { + var typeArgs; + var reference; + if (t.target && getAccessibleSymbolChain(t.target.symbol, enclosingDeclaration, 111551, false)) { + typeArgs = ts.map(getTypeArguments(t), function (t) { return typeToTypeNodeHelper(t, context); }); + reference = symbolToExpression(t.target.symbol, context, 788968); + } + else if (t.symbol && getAccessibleSymbolChain(t.symbol, enclosingDeclaration, 111551, false)) { + reference = symbolToExpression(t.symbol, context, 788968); + } + if (reference) { + return ts.createExpressionWithTypeArguments(typeArgs, reference); + } + } + function getUnusedName(input, symbol) { + if (symbol) { + if (context.remappedSymbolNames.has("" + getSymbolId(symbol))) { + return context.remappedSymbolNames.get("" + getSymbolId(symbol)); + } + } + if (symbol) { + input = getNameCandidateWorker(symbol, input); + } + var i = 0; + var original = input; + while (context.usedSymbolNames.has(input)) { + i++; + input = original + "_" + i; + } + context.usedSymbolNames.set(input, true); + if (symbol) { + context.remappedSymbolNames.set("" + getSymbolId(symbol), input); + } + return input; + } + function getNameCandidateWorker(symbol, localName) { + if (localName === "default" || localName === "__class" || localName === "__function") { + var flags = context.flags; + context.flags |= 16777216; + var nameCandidate = getNameOfSymbolAsWritten(symbol, context); + context.flags = flags; + localName = nameCandidate.length > 0 && ts.isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? ts.stripQuotes(nameCandidate) : nameCandidate; + } + if (localName === "default") { + localName = "_default"; + } + else if (localName === "export=") { + localName = "_exports"; + } + localName = ts.isIdentifierText(localName, languageVersion) && !ts.isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_"); + return localName; + } + function getInternalSymbolName(symbol, localName) { + if (context.remappedSymbolNames.has("" + getSymbolId(symbol))) { + return context.remappedSymbolNames.get("" + getSymbolId(symbol)); + } + localName = getNameCandidateWorker(symbol, localName); + context.remappedSymbolNames.set("" + getSymbolId(symbol), localName); + return localName; + } + } + } + function typePredicateToString(typePredicate, enclosingDeclaration, flags, writer) { + if (flags === void 0) { flags = 16384; } + return writer ? typePredicateToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(typePredicateToStringWorker); + function typePredicateToStringWorker(writer) { + var predicate = ts.createTypePredicateNodeWithModifier(typePredicate.kind === 2 || typePredicate.kind === 3 ? ts.createToken(124) : undefined, typePredicate.kind === 1 || typePredicate.kind === 3 ? ts.createIdentifier(typePredicate.parameterName) : ts.createThisTypeNode(), typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512)); + var printer = ts.createPrinter({ removeComments: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4, predicate, sourceFile, writer); + return writer; + } + } + function formatUnionTypes(types) { + var result = []; + var flags = 0; + for (var i = 0; i < types.length; i++) { + var t = types[i]; + flags |= t.flags; + if (!(t.flags & 98304)) { + if (t.flags & (512 | 1024)) { + var baseType = t.flags & 512 ? booleanType : getBaseTypeOfEnumLiteralType(t); + if (baseType.flags & 1048576) { + var count = baseType.types.length; + if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) { + result.push(baseType); + i += count - 1; + continue; + } + } + } + result.push(t); + } + } + if (flags & 65536) + result.push(nullType); + if (flags & 32768) + result.push(undefinedType); + return result || types; + } + function visibilityToString(flags) { + if (flags === 8) { + return "private"; + } + if (flags === 16) { + return "protected"; + } + return "public"; + } + function getTypeAliasForTypeLiteral(type) { + if (type.symbol && type.symbol.flags & 2048) { + var node = ts.findAncestor(type.symbol.declarations[0].parent, function (n) { return n.kind !== 182; }); + if (node.kind === 247) { + return getSymbolOfNode(node); + } + } + return undefined; + } + function isTopLevelInExternalModuleAugmentation(node) { + return node && node.parent && + node.parent.kind === 250 && + ts.isExternalModuleAugmentation(node.parent.parent); + } + function isDefaultBindingContext(location) { + return location.kind === 290 || ts.isAmbientModule(location); + } + function getNameOfSymbolFromNameType(symbol, context) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType) { + if (nameType.flags & 384) { + var name = "" + nameType.value; + if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) { + return "\"" + ts.escapeString(name, 34) + "\""; + } + if (isNumericLiteralName(name) && ts.startsWith(name, "-")) { + return "[" + name + "]"; + } + return name; + } + if (nameType.flags & 8192) { + return "[" + getNameOfSymbolAsWritten(nameType.symbol, context) + "]"; + } + } + } + function getNameOfSymbolAsWritten(symbol, context) { + if (context && symbol.escapedName === "default" && !(context.flags & 16384) && + (!(context.flags & 16777216) || + !symbol.declarations || + (context.enclosingDeclaration && ts.findAncestor(symbol.declarations[0], isDefaultBindingContext) !== ts.findAncestor(context.enclosingDeclaration, isDefaultBindingContext)))) { + return "default"; + } + if (symbol.declarations && symbol.declarations.length) { + var declaration = ts.firstDefined(symbol.declarations, function (d) { return ts.getNameOfDeclaration(d) ? d : undefined; }); + var name_2 = declaration && ts.getNameOfDeclaration(declaration); + if (declaration && name_2) { + if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) { + return ts.symbolName(symbol); + } + if (ts.isComputedPropertyName(name_2) && !(ts.getCheckFlags(symbol) & 4096)) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType && nameType.flags & 384) { + var result = getNameOfSymbolFromNameType(symbol, context); + if (result !== undefined) { + return result; + } + } + } + return ts.declarationNameToString(name_2); + } + if (!declaration) { + declaration = symbol.declarations[0]; + } + if (declaration.parent && declaration.parent.kind === 242) { + return ts.declarationNameToString(declaration.parent.name); + } + switch (declaration.kind) { + case 214: + case 201: + case 202: + if (context && !context.encounteredError && !(context.flags & 131072)) { + context.encounteredError = true; + } + return declaration.kind === 214 ? "(Anonymous class)" : "(Anonymous function)"; + } + } + var name = getNameOfSymbolFromNameType(symbol, context); + return name !== undefined ? name : ts.symbolName(symbol); + } + function isDeclarationVisible(node) { + if (node) { + var links = getNodeLinks(node); + if (links.isVisible === undefined) { + links.isVisible = !!determineIfDeclarationIsVisible(); + } + return links.isVisible; + } + return false; + function determineIfDeclarationIsVisible() { + switch (node.kind) { + case 314: + case 321: + case 315: + return !!(node.parent && node.parent.parent && node.parent.parent.parent && ts.isSourceFile(node.parent.parent.parent)); + case 191: + return isDeclarationVisible(node.parent.parent); + case 242: + if (ts.isBindingPattern(node.name) && + !node.name.elements.length) { + return false; + } + case 249: + case 245: + case 246: + case 247: + case 244: + case 248: + case 253: + if (ts.isExternalModuleAugmentation(node)) { + return true; + } + var parent = getDeclarationContainer(node); + if (!(ts.getCombinedModifierFlags(node) & 1) && + !(node.kind !== 253 && parent.kind !== 290 && parent.flags & 8388608)) { + return isGlobalSourceFile(parent); + } + return isDeclarationVisible(parent); + case 159: + case 158: + case 163: + case 164: + case 161: + case 160: + if (ts.hasModifier(node, 8 | 16)) { + return false; + } + case 162: + case 166: + case 165: + case 167: + case 156: + case 250: + case 170: + case 171: + case 173: + case 169: + case 174: + case 175: + case 178: + case 179: + case 182: + return isDeclarationVisible(node.parent); + case 255: + case 256: + case 258: + return false; + case 155: + case 290: + case 252: + return true; + case 259: + return false; + default: + return false; + } + } + } + function collectLinkedAliases(node, setVisibility) { + var exportSymbol; + if (node.parent && node.parent.kind === 259) { + exportSymbol = resolveName(node, node.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, node, false); + } + else if (node.parent.kind === 263) { + exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 | 788968 | 1920 | 2097152); + } + var result; + var visited; + if (exportSymbol) { + visited = ts.createMap(); + visited.set("" + getSymbolId(exportSymbol), true); + buildVisibleNodeList(exportSymbol.declarations); + } + return result; + function buildVisibleNodeList(declarations) { + ts.forEach(declarations, function (declaration) { + var resultNode = getAnyImportSyntax(declaration) || declaration; + if (setVisibility) { + getNodeLinks(declaration).isVisible = true; + } + else { + result = result || []; + ts.pushIfUnique(result, resultNode); + } + if (ts.isInternalModuleImportEqualsDeclaration(declaration)) { + var internalModuleReference = declaration.moduleReference; + var firstIdentifier = ts.getFirstIdentifier(internalModuleReference); + var importSymbol = resolveName(declaration, firstIdentifier.escapedText, 111551 | 788968 | 1920, undefined, undefined, false); + var id = importSymbol && "" + getSymbolId(importSymbol); + if (importSymbol && !visited.has(id)) { + visited.set(id, true); + buildVisibleNodeList(importSymbol.declarations); + } + } + }); + } + } + function pushTypeResolution(target, propertyName) { + var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName); + if (resolutionCycleStartIndex >= 0) { + var length_2 = resolutionTargets.length; + for (var i = resolutionCycleStartIndex; i < length_2; i++) { + resolutionResults[i] = false; + } + return false; + } + resolutionTargets.push(target); + resolutionResults.push(true); + resolutionPropertyNames.push(propertyName); + return true; + } + function findResolutionCycleStartIndex(target, propertyName) { + for (var i = resolutionTargets.length - 1; i >= 0; i--) { + if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) { + return -1; + } + if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) { + return i; + } + } + return -1; + } + function hasType(target, propertyName) { + switch (propertyName) { + case 0: + return !!getSymbolLinks(target).type; + case 5: + return !!(getNodeLinks(target).resolvedEnumType); + case 2: + return !!getSymbolLinks(target).declaredType; + case 1: + return !!target.resolvedBaseConstructorType; + case 3: + return !!target.resolvedReturnType; + case 4: + return !!target.immediateBaseConstraint; + case 6: + return !!target.resolvedTypeArguments; + } + return ts.Debug.assertNever(propertyName); + } + function popTypeResolution() { + resolutionTargets.pop(); + resolutionPropertyNames.pop(); + return resolutionResults.pop(); + } + function getDeclarationContainer(node) { + return ts.findAncestor(ts.getRootDeclaration(node), function (node) { + switch (node.kind) { + case 242: + case 243: + case 258: + case 257: + case 256: + case 255: + return false; + default: + return true; + } + }).parent; + } + function getTypeOfPrototypeProperty(prototype) { + var classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype)); + return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType; + } + function getTypeOfPropertyOfType(type, name) { + var prop = getPropertyOfType(type, name); + return prop ? getTypeOfSymbol(prop) : undefined; + } + function getTypeOfPropertyOrIndexSignature(type, name) { + return getTypeOfPropertyOfType(type, name) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || unknownType; + } + function isTypeAny(type) { + return type && (type.flags & 1) !== 0; + } + function getTypeForBindingElementParent(node) { + var symbol = getSymbolOfNode(node); + return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false); + } + function isComputedNonLiteralName(name) { + return name.kind === 154 && !ts.isStringOrNumericLiteralLike(name.expression); + } + function getRestType(source, properties, symbol) { + source = filterType(source, function (t) { return !(t.flags & 98304); }); + if (source.flags & 131072) { + return emptyObjectType; + } + if (source.flags & 1048576) { + return mapType(source, function (t) { return getRestType(t, properties, symbol); }); + } + var omitKeyType = getUnionType(ts.map(properties, getLiteralTypeFromPropertyName)); + if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) { + if (omitKeyType.flags & 131072) { + return source; + } + var omitTypeAlias = getGlobalOmitSymbol(); + if (!omitTypeAlias) { + return errorType; + } + return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]); + } + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) { + var prop = _a[_i]; + if (!isTypeAssignableTo(getLiteralTypeFromProperty(prop, 8576), omitKeyType) + && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16)) + && isSpreadableProperty(prop)) { + members.set(prop.escapedName, getSpreadSymbol(prop, false)); + } + } + var stringIndexInfo = getIndexInfoOfType(source, 0); + var numberIndexInfo = getIndexInfoOfType(source, 1); + var result = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo); + result.objectFlags |= 131072; + return result; + } + function getFlowTypeOfDestructuring(node, declaredType) { + var reference = getSyntheticElementAccess(node); + return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType; + } + function getSyntheticElementAccess(node) { + var parentAccess = getParentElementAccess(node); + if (parentAccess && parentAccess.flowNode) { + var propName = getDestructuringPropertyName(node); + if (propName) { + var result = ts.createNode(195, node.pos, node.end); + result.parent = node; + result.expression = parentAccess; + var literal = ts.createNode(10, node.pos, node.end); + literal.parent = result; + literal.text = propName; + result.argumentExpression = literal; + result.flowNode = parentAccess.flowNode; + return result; + } + } + } + function getParentElementAccess(node) { + var ancestor = node.parent.parent; + switch (ancestor.kind) { + case 191: + case 281: + return getSyntheticElementAccess(ancestor); + case 192: + return getSyntheticElementAccess(node.parent); + case 242: + return ancestor.initializer; + case 209: + return ancestor.right; + } + } + function getDestructuringPropertyName(node) { + var parent = node.parent; + if (node.kind === 191 && parent.kind === 189) { + return getLiteralPropertyNameText(node.propertyName || node.name); + } + if (node.kind === 281 || node.kind === 282) { + return getLiteralPropertyNameText(node.name); + } + return "" + parent.elements.indexOf(node); + } + function getLiteralPropertyNameText(name) { + var type = getLiteralTypeFromPropertyName(name); + return type.flags & (128 | 256) ? "" + type.value : undefined; + } + function getTypeForBindingElement(declaration) { + var pattern = declaration.parent; + var parentType = getTypeForBindingElementParent(pattern.parent); + if (!parentType || isTypeAny(parentType)) { + return parentType; + } + if (strictNullChecks && declaration.flags & 8388608 && ts.isParameterDeclaration(declaration)) { + parentType = getNonNullableType(parentType); + } + var type; + if (pattern.kind === 189) { + if (declaration.dotDotDotToken) { + if (parentType.flags & 2 || !isValidSpreadType(parentType)) { + error(declaration, ts.Diagnostics.Rest_types_may_only_be_created_from_object_types); + return errorType; + } + var literalMembers = []; + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!element.dotDotDotToken) { + literalMembers.push(element.propertyName || element.name); + } + } + type = getRestType(parentType, literalMembers, declaration.symbol); + } + else { + var name = declaration.propertyName || declaration.name; + var indexType = getLiteralTypeFromPropertyName(name); + var declaredType = getConstraintForLocation(getIndexedAccessType(parentType, indexType, name), declaration.name); + type = getFlowTypeOfDestructuring(declaration, declaredType); + } + } + else { + var elementType = checkIteratedTypeOrElementType(65, parentType, undefinedType, pattern); + var index_1 = pattern.elements.indexOf(declaration); + if (declaration.dotDotDotToken) { + type = everyType(parentType, isTupleType) ? + mapType(parentType, function (t) { return sliceTupleType(t, index_1); }) : + createArrayType(elementType); + } + else if (isArrayLikeType(parentType)) { + var indexType = getLiteralType(index_1); + var accessFlags = hasDefaultValue(declaration) ? 8 : 0; + var declaredType = getConstraintForLocation(getIndexedAccessTypeOrUndefined(parentType, indexType, declaration.name, accessFlags) || errorType, declaration.name); + type = getFlowTypeOfDestructuring(declaration, declaredType); + } + else { + type = elementType; + } + } + if (!declaration.initializer) { + return type; + } + if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) { + return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration)) & 32768) ? + getTypeWithFacts(type, 524288) : + type; + } + return widenTypeInferredFromInitializer(declaration, getUnionType([getTypeWithFacts(type, 524288), checkDeclarationInitializer(declaration)], 2)); + } + function getTypeForDeclarationFromJSDocComment(declaration) { + var jsdocType = ts.getJSDocType(declaration); + if (jsdocType) { + return getTypeFromTypeNode(jsdocType); + } + return undefined; + } + function isNullOrUndefined(node) { + var expr = ts.skipParentheses(node); + return expr.kind === 100 || expr.kind === 75 && getResolvedSymbol(expr) === undefinedSymbol; + } + function isEmptyArrayLiteral(node) { + var expr = ts.skipParentheses(node); + return expr.kind === 192 && expr.elements.length === 0; + } + function addOptionality(type, optional) { + if (optional === void 0) { optional = true; } + return strictNullChecks && optional ? getOptionalType(type) : type; + } + function getTypeForVariableLikeDeclaration(declaration, includeOptionality) { + if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 231) { + var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression))); + return indexType.flags & (262144 | 4194304) ? getExtractStringType(indexType) : stringType; + } + if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 232) { + var forOfStatement = declaration.parent.parent; + return checkRightHandSideOfForOf(forOfStatement.expression, forOfStatement.awaitModifier) || anyType; + } + if (ts.isBindingPattern(declaration.parent)) { + return getTypeForBindingElement(declaration); + } + var isOptional = includeOptionality && (ts.isParameter(declaration) && isJSDocOptionalParameter(declaration) + || !ts.isBindingElement(declaration) && !ts.isVariableDeclaration(declaration) && !!declaration.questionToken); + var declaredType = tryGetTypeFromEffectiveTypeNode(declaration); + if (declaredType) { + return addOptionality(declaredType, isOptional); + } + if ((noImplicitAny || ts.isInJSFile(declaration)) && + declaration.kind === 242 && !ts.isBindingPattern(declaration.name) && + !(ts.getCombinedModifierFlags(declaration) & 1) && !(declaration.flags & 8388608)) { + if (!(ts.getCombinedNodeFlags(declaration) & 2) && (!declaration.initializer || isNullOrUndefined(declaration.initializer))) { + return autoType; + } + if (declaration.initializer && isEmptyArrayLiteral(declaration.initializer)) { + return autoArrayType; + } + } + if (declaration.kind === 156) { + var func = declaration.parent; + if (func.kind === 164 && !hasNonBindableDynamicName(func)) { + var getter = ts.getDeclarationOfKind(getSymbolOfNode(declaration.parent), 163); + if (getter) { + var getterSignature = getSignatureFromDeclaration(getter); + var thisParameter = getAccessorThisParameter(func); + if (thisParameter && declaration === thisParameter) { + ts.Debug.assert(!thisParameter.type); + return getTypeOfSymbol(getterSignature.thisParameter); + } + return getReturnTypeOfSignature(getterSignature); + } + } + if (ts.isInJSFile(declaration)) { + var typeTag = ts.getJSDocType(func); + if (typeTag && ts.isFunctionTypeNode(typeTag)) { + return getTypeAtPosition(getSignatureFromDeclaration(typeTag), func.parameters.indexOf(declaration)); + } + } + var type = declaration.symbol.escapedName === "this" ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration); + if (type) { + return addOptionality(type, isOptional); + } + } + else if (ts.isInJSFile(declaration)) { + var containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), ts.getDeclaredExpandoInitializer(declaration)); + if (containerObjectType) { + return containerObjectType; + } + } + if (declaration.initializer) { + var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration)); + return addOptionality(type, isOptional); + } + if (ts.isJsxAttribute(declaration)) { + return trueType; + } + if (ts.isBindingPattern(declaration.name)) { + return getTypeFromBindingPattern(declaration.name, false, true); + } + return undefined; + } + function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) { + var container = ts.getAssignedExpandoInitializer(symbol.valueDeclaration); + if (container) { + var tag = ts.getJSDocTypeTag(container); + if (tag && tag.typeExpression) { + return getTypeFromTypeNode(tag.typeExpression); + } + var containerObjectType = getJSContainerObjectType(symbol.valueDeclaration, symbol, container); + return containerObjectType || getWidenedLiteralType(checkExpressionCached(container)); + } + var definedInConstructor = false; + var definedInMethod = false; + var jsdocType; + var types; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var expression = (ts.isBinaryExpression(declaration) || ts.isCallExpression(declaration)) ? declaration : + ts.isAccessExpression(declaration) ? ts.isBinaryExpression(declaration.parent) ? declaration.parent : declaration : + undefined; + if (!expression) { + continue; + } + var kind = ts.isAccessExpression(expression) + ? ts.getAssignmentDeclarationPropertyAccessKind(expression) + : ts.getAssignmentDeclarationKind(expression); + if (kind === 4) { + if (isDeclarationInConstructor(expression)) { + definedInConstructor = true; + } + else { + definedInMethod = true; + } + } + if (!ts.isCallExpression(expression)) { + jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration); + } + if (!jsdocType) { + (types || (types = [])).push((ts.isBinaryExpression(expression) || ts.isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType); + } + } + var type = jsdocType; + if (!type) { + if (!ts.length(types)) { + return errorType; + } + var constructorTypes = definedInConstructor ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : undefined; + if (definedInMethod) { + var propType = getTypeOfAssignmentDeclarationPropertyOfBaseType(symbol); + if (propType) { + (constructorTypes || (constructorTypes = [])).push(propType); + definedInConstructor = true; + } + } + var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304); }) ? constructorTypes : types; + type = getUnionType(sourceTypes, 2); + } + var widened = getWidenedType(addOptionality(type, definedInMethod && !definedInConstructor)); + if (filterType(widened, function (t) { return !!(t.flags & ~98304); }) === neverType) { + reportImplicitAny(symbol.valueDeclaration, anyType); + return anyType; + } + return widened; + } + function getJSContainerObjectType(decl, symbol, init) { + if (!ts.isInJSFile(decl) || !init || !ts.isObjectLiteralExpression(init) || init.properties.length) { + return undefined; + } + var exports = ts.createSymbolTable(); + while (ts.isBinaryExpression(decl) || ts.isPropertyAccessExpression(decl)) { + var s_2 = getSymbolOfNode(decl); + if (s_2 && ts.hasEntries(s_2.exports)) { + mergeSymbolTable(exports, s_2.exports); + } + decl = ts.isBinaryExpression(decl) ? decl.parent : decl.parent.parent; + } + var s = getSymbolOfNode(decl); + if (s && ts.hasEntries(s.exports)) { + mergeSymbolTable(exports, s.exports); + } + var type = createAnonymousType(symbol, exports, ts.emptyArray, ts.emptyArray, undefined, undefined); + type.objectFlags |= 16384; + return type; + } + function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) { + var typeNode = ts.getEffectiveTypeAnnotationNode(expression.parent); + if (typeNode) { + var type = getWidenedType(getTypeFromTypeNode(typeNode)); + if (!declaredType) { + return type; + } + else if (declaredType !== errorType && type !== errorType && !isTypeIdenticalTo(declaredType, type)) { + errorNextVariableOrPropertyDeclarationMustHaveSameType(undefined, declaredType, declaration, type); + } + } + if (symbol.parent) { + var typeNode_2 = ts.getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration); + if (typeNode_2) { + return getTypeOfPropertyOfType(getTypeFromTypeNode(typeNode_2), symbol.escapedName); + } + } + return declaredType; + } + function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) { + if (ts.isCallExpression(expression)) { + if (resolvedSymbol) { + return getTypeOfSymbol(resolvedSymbol); + } + var objectLitType = checkExpressionCached(expression.arguments[2]); + var valueType = getTypeOfPropertyOfType(objectLitType, "value"); + if (valueType) { + return valueType; + } + var getFunc = getTypeOfPropertyOfType(objectLitType, "get"); + if (getFunc) { + var getSig = getSingleCallSignature(getFunc); + if (getSig) { + return getReturnTypeOfSignature(getSig); + } + } + var setFunc = getTypeOfPropertyOfType(objectLitType, "set"); + if (setFunc) { + var setSig = getSingleCallSignature(setFunc); + if (setSig) { + return getTypeOfFirstParameterOfSignature(setSig); + } + } + return anyType; + } + var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right)); + if (type.flags & 524288 && + kind === 2 && + symbol.escapedName === "export=") { + var exportedType_1 = resolveStructuredTypeMembers(type); + var members_4 = ts.createSymbolTable(); + ts.copyEntries(exportedType_1.members, members_4); + if (resolvedSymbol && !resolvedSymbol.exports) { + resolvedSymbol.exports = ts.createSymbolTable(); + } + (resolvedSymbol || symbol).exports.forEach(function (s, name) { + if (members_4.has(name)) { + var exportedMember = exportedType_1.members.get(name); + var union = createSymbol(s.flags | exportedMember.flags, name); + union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]); + members_4.set(name, union); + } + else { + members_4.set(name, s); + } + }); + var result = createAnonymousType(exportedType_1.symbol, members_4, exportedType_1.callSignatures, exportedType_1.constructSignatures, exportedType_1.stringIndexInfo, exportedType_1.numberIndexInfo); + result.objectFlags |= (ts.getObjectFlags(type) & 16384); + return result; + } + if (isEmptyArrayLiteralType(type)) { + reportImplicitAny(expression, anyArrayType); + return anyArrayType; + } + return type; + } + function isDeclarationInConstructor(expression) { + var thisContainer = ts.getThisContainer(expression, false); + return thisContainer.kind === 162 || + thisContainer.kind === 244 || + (thisContainer.kind === 201 && !ts.isPrototypePropertyAssignment(thisContainer.parent)); + } + function getConstructorDefinedThisAssignmentTypes(types, declarations) { + ts.Debug.assert(types.length === declarations.length); + return types.filter(function (_, i) { + var declaration = declarations[i]; + var expression = ts.isBinaryExpression(declaration) ? declaration : + ts.isBinaryExpression(declaration.parent) ? declaration.parent : undefined; + return expression && isDeclarationInConstructor(expression); + }); + } + function getTypeOfAssignmentDeclarationPropertyOfBaseType(property) { + var parentDeclaration = ts.forEach(property.declarations, function (d) { + var parent = ts.getThisContainer(d, false).parent; + return ts.isClassLike(parent) && parent; + }); + if (parentDeclaration) { + var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(parentDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (baseClassType) { + return getTypeOfPropertyOfType(baseClassType, property.escapedName); + } + } + } + function getTypeFromBindingElement(element, includePatternInType, reportErrors) { + if (element.initializer) { + var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType; + return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType))); + } + if (ts.isBindingPattern(element.name)) { + return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors); + } + if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) { + reportImplicitAny(element, anyType); + } + return includePatternInType ? nonInferrableAnyType : anyType; + } + function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) { + var members = ts.createSymbolTable(); + var stringIndexInfo; + var objectFlags = 128 | 1048576; + ts.forEach(pattern.elements, function (e) { + var name = e.propertyName || e.name; + if (e.dotDotDotToken) { + stringIndexInfo = createIndexInfo(anyType, false); + return; + } + var exprType = getLiteralTypeFromPropertyName(name); + if (!isTypeUsableAsPropertyName(exprType)) { + objectFlags |= 512; + return; + } + var text = getPropertyNameFromType(exprType); + var flags = 4 | (e.initializer ? 16777216 : 0); + var symbol = createSymbol(flags, text); + symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors); + symbol.bindingElement = e; + members.set(symbol.escapedName, symbol); + }); + var result = createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined); + result.objectFlags |= objectFlags; + if (includePatternInType) { + result.pattern = pattern; + result.objectFlags |= 1048576; + } + return result; + } + function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors) { + var elements = pattern.elements; + var lastElement = ts.lastOrUndefined(elements); + var hasRestElement = !!(lastElement && lastElement.kind === 191 && lastElement.dotDotDotToken); + if (elements.length === 0 || elements.length === 1 && hasRestElement) { + return languageVersion >= 2 ? createIterableType(anyType) : anyArrayType; + } + var elementTypes = ts.map(elements, function (e) { return ts.isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); }); + var minLength = ts.findLastIndex(elements, function (e) { return !ts.isOmittedExpression(e) && !hasDefaultValue(e); }, elements.length - (hasRestElement ? 2 : 1)) + 1; + var result = createTupleType(elementTypes, minLength, hasRestElement); + if (includePatternInType) { + result = cloneTypeReference(result); + result.pattern = pattern; + result.objectFlags |= 1048576; + } + return result; + } + function getTypeFromBindingPattern(pattern, includePatternInType, reportErrors) { + if (includePatternInType === void 0) { includePatternInType = false; } + if (reportErrors === void 0) { reportErrors = false; } + return pattern.kind === 189 + ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) + : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors); + } + function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { + return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, true), declaration, reportErrors); + } + function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors) { + if (type) { + if (reportErrors) { + reportErrorsFromWidening(declaration, type); + } + if (type.flags & 8192 && (ts.isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) { + type = esSymbolType; + } + return getWidenedType(type); + } + type = ts.isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType; + if (reportErrors) { + if (!declarationBelongsToPrivateAmbientMember(declaration)) { + reportImplicitAny(declaration, type); + } + } + return type; + } + function declarationBelongsToPrivateAmbientMember(declaration) { + var root = ts.getRootDeclaration(declaration); + var memberDeclaration = root.kind === 156 ? root.parent : root; + return isPrivateWithinAmbient(memberDeclaration); + } + function tryGetTypeFromEffectiveTypeNode(declaration) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + } + function getTypeOfVariableOrParameterOrProperty(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol); + if (!links.type) { + links.type = type; + } + } + return links.type; + } + function getTypeOfVariableOrParameterOrPropertyWorker(symbol) { + if (symbol.flags & 4194304) { + return getTypeOfPrototypeProperty(symbol); + } + if (symbol === requireSymbol) { + return anyType; + } + if (symbol.flags & 134217728) { + var fileSymbol = getSymbolOfNode(ts.getSourceFileOfNode(symbol.valueDeclaration)); + var members = ts.createSymbolTable(); + members.set("exports", fileSymbol); + return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, undefined, undefined); + } + var declaration = symbol.valueDeclaration; + if (ts.isCatchClauseVariableDeclarationOrBindingElement(declaration)) { + return anyType; + } + if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) { + if (!declaration.statements.length) { + return emptyObjectType; + } + return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression))); + } + if (!pushTypeResolution(symbol, 0)) { + if (symbol.flags & 512 && !(symbol.flags & 67108864)) { + return getTypeOfFuncClassEnumModule(symbol); + } + return reportCircularityError(symbol); + } + var type; + if (declaration.kind === 259) { + type = widenTypeForVariableLikeDeclaration(checkExpressionCached(declaration.expression), declaration); + } + else if (ts.isBinaryExpression(declaration) || + (ts.isInJSFile(declaration) && + (ts.isCallExpression(declaration) || (ts.isPropertyAccessExpression(declaration) || ts.isBindableStaticElementAccessExpression(declaration)) && ts.isBinaryExpression(declaration.parent)))) { + type = getWidenedTypeForAssignmentDeclaration(symbol); + } + else if (ts.isJSDocPropertyLikeTag(declaration) + || ts.isPropertyAccessExpression(declaration) + || ts.isElementAccessExpression(declaration) + || ts.isIdentifier(declaration) + || ts.isStringLiteralLike(declaration) + || ts.isNumericLiteral(declaration) + || ts.isClassDeclaration(declaration) + || ts.isFunctionDeclaration(declaration) + || (ts.isMethodDeclaration(declaration) && !ts.isObjectLiteralMethod(declaration)) + || ts.isMethodSignature(declaration) + || ts.isSourceFile(declaration)) { + if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) { + return getTypeOfFuncClassEnumModule(symbol); + } + type = ts.isBinaryExpression(declaration.parent) ? + getWidenedTypeForAssignmentDeclaration(symbol) : + tryGetTypeFromEffectiveTypeNode(declaration) || anyType; + } + else if (ts.isPropertyAssignment(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration); + } + else if (ts.isJsxAttribute(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration); + } + else if (ts.isShorthandPropertyAssignment(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0); + } + else if (ts.isObjectLiteralMethod(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0); + } + else if (ts.isParameter(declaration) + || ts.isPropertyDeclaration(declaration) + || ts.isPropertySignature(declaration) + || ts.isVariableDeclaration(declaration) + || ts.isBindingElement(declaration)) { + type = getWidenedTypeForVariableLikeDeclaration(declaration, true); + } + else if (ts.isEnumDeclaration(declaration)) { + type = getTypeOfFuncClassEnumModule(symbol); + } + else if (ts.isEnumMember(declaration)) { + type = getTypeOfEnumMember(symbol); + } + else if (ts.isAccessor(declaration)) { + type = resolveTypeOfAccessors(symbol); + } + else { + return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol)); + } + if (!popTypeResolution()) { + if (symbol.flags & 512 && !(symbol.flags & 67108864)) { + return getTypeOfFuncClassEnumModule(symbol); + } + return reportCircularityError(symbol); + } + return type; + } + function getAnnotatedAccessorTypeNode(accessor) { + if (accessor) { + if (accessor.kind === 163) { + var getterTypeAnnotation = ts.getEffectiveReturnTypeNode(accessor); + return getterTypeAnnotation; + } + else { + var setterTypeAnnotation = ts.getEffectiveSetAccessorTypeAnnotationNode(accessor); + return setterTypeAnnotation; + } + } + return undefined; + } + function getAnnotatedAccessorType(accessor) { + var node = getAnnotatedAccessorTypeNode(accessor); + return node && getTypeFromTypeNode(node); + } + function getAnnotatedAccessorThisParameter(accessor) { + var parameter = getAccessorThisParameter(accessor); + return parameter && parameter.symbol; + } + function getThisTypeOfDeclaration(declaration) { + return getThisTypeOfSignature(getSignatureFromDeclaration(declaration)); + } + function getTypeOfAccessors(symbol) { + var links = getSymbolLinks(symbol); + return links.type || (links.type = getTypeOfAccessorsWorker(symbol)); + } + function getTypeOfAccessorsWorker(symbol) { + if (!pushTypeResolution(symbol, 0)) { + return errorType; + } + var type = resolveTypeOfAccessors(symbol); + if (!popTypeResolution()) { + type = anyType; + if (noImplicitAny) { + var getter = ts.getDeclarationOfKind(symbol, 163); + error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); + } + } + return type; + } + function resolveTypeOfAccessors(symbol) { + var getter = ts.getDeclarationOfKind(symbol, 163); + var setter = ts.getDeclarationOfKind(symbol, 164); + if (getter && ts.isInJSFile(getter)) { + var jsDocType = getTypeForDeclarationFromJSDocComment(getter); + if (jsDocType) { + return jsDocType; + } + } + var getterReturnType = getAnnotatedAccessorType(getter); + if (getterReturnType) { + return getterReturnType; + } + else { + var setterParameterType = getAnnotatedAccessorType(setter); + if (setterParameterType) { + return setterParameterType; + } + else { + if (getter && getter.body) { + return getReturnTypeFromBody(getter); + } + else { + if (setter) { + if (!isPrivateWithinAmbient(setter)) { + errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol)); + } + } + else { + ts.Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function"); + if (!isPrivateWithinAmbient(getter)) { + errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol)); + } + } + return anyType; + } + } + } + } + function getBaseTypeVariableOfClass(symbol) { + var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol)); + return baseConstructorType.flags & 8650752 ? baseConstructorType : + baseConstructorType.flags & 2097152 ? ts.find(baseConstructorType.types, function (t) { return !!(t.flags & 8650752); }) : + undefined; + } + function getTypeOfFuncClassEnumModule(symbol) { + var links = getSymbolLinks(symbol); + var originalLinks = links; + if (!links.type) { + var jsDeclaration = ts.getDeclarationOfExpando(symbol.valueDeclaration); + if (jsDeclaration) { + var merged = mergeJSSymbols(symbol, getSymbolOfNode(jsDeclaration)); + if (merged) { + symbol = links = merged; + } + } + originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol); + } + return links.type; + } + function getTypeOfFuncClassEnumModuleWorker(symbol) { + var declaration = symbol.valueDeclaration; + if (symbol.flags & 1536 && ts.isShorthandAmbientModuleSymbol(symbol)) { + return anyType; + } + else if (declaration.kind === 209 || + ts.isAccessExpression(declaration) && + declaration.parent.kind === 209) { + return getWidenedTypeForAssignmentDeclaration(symbol); + } + else if (symbol.flags & 512 && declaration && ts.isSourceFile(declaration) && declaration.commonJsModuleIndicator) { + var resolvedModule = resolveExternalModuleSymbol(symbol); + if (resolvedModule !== symbol) { + if (!pushTypeResolution(symbol, 0)) { + return errorType; + } + var exportEquals = getMergedSymbol(symbol.exports.get("export=")); + var type_1 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule); + if (!popTypeResolution()) { + return reportCircularityError(symbol); + } + return type_1; + } + } + var type = createObjectType(16, symbol); + if (symbol.flags & 32) { + var baseTypeVariable = getBaseTypeVariableOfClass(symbol); + return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type; + } + else { + return strictNullChecks && symbol.flags & 16777216 ? getOptionalType(type) : type; + } + } + function getTypeOfEnumMember(symbol) { + var links = getSymbolLinks(symbol); + return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol)); + } + function getTypeOfAlias(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + var targetSymbol = resolveAlias(symbol); + links.type = targetSymbol.flags & 111551 + ? getTypeOfSymbol(targetSymbol) + : errorType; + } + return links.type; + } + function getTypeOfInstantiatedSymbol(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + if (!pushTypeResolution(symbol, 0)) { + return links.type = errorType; + } + var type = instantiateType(getTypeOfSymbol(links.target), links.mapper); + if (!popTypeResolution()) { + type = reportCircularityError(symbol); + } + links.type = type; + } + return links.type; + } + function reportCircularityError(symbol) { + var declaration = symbol.valueDeclaration; + if (ts.getEffectiveTypeAnnotationNode(declaration)) { + error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + return errorType; + } + if (noImplicitAny && (declaration.kind !== 156 || declaration.initializer)) { + error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol)); + } + return anyType; + } + function getTypeOfSymbolWithDeferredType(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + ts.Debug.assertDefined(links.deferralParent); + ts.Debug.assertDefined(links.deferralConstituents); + links.type = links.deferralParent.flags & 1048576 ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents); + } + return links.type; + } + function getTypeOfSymbol(symbol) { + if (ts.getCheckFlags(symbol) & 65536) { + return getTypeOfSymbolWithDeferredType(symbol); + } + if (ts.getCheckFlags(symbol) & 1) { + return getTypeOfInstantiatedSymbol(symbol); + } + if (ts.getCheckFlags(symbol) & 8192) { + return getTypeOfReverseMappedSymbol(symbol); + } + if (symbol.flags & (3 | 4)) { + return getTypeOfVariableOrParameterOrProperty(symbol); + } + if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) { + return getTypeOfFuncClassEnumModule(symbol); + } + if (symbol.flags & 8) { + return getTypeOfEnumMember(symbol); + } + if (symbol.flags & 98304) { + return getTypeOfAccessors(symbol); + } + if (symbol.flags & 2097152) { + return getTypeOfAlias(symbol); + } + return errorType; + } + function isReferenceToType(type, target) { + return type !== undefined + && target !== undefined + && (ts.getObjectFlags(type) & 4) !== 0 + && type.target === target; + } + function getTargetType(type) { + return ts.getObjectFlags(type) & 4 ? type.target : type; + } + function hasBaseType(type, checkBase) { + return check(type); + function check(type) { + if (ts.getObjectFlags(type) & (3 | 4)) { + var target = getTargetType(type); + return target === checkBase || ts.some(getBaseTypes(target), check); + } + else if (type.flags & 2097152) { + return ts.some(type.types, check); + } + return false; + } + } + function appendTypeParameters(typeParameters, declarations) { + for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) { + var declaration = declarations_2[_i]; + typeParameters = ts.appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration))); + } + return typeParameters; + } + function getOuterTypeParameters(node, includeThisTypes) { + while (true) { + node = node.parent; + if (node && ts.isBinaryExpression(node)) { + var assignmentKind = ts.getAssignmentDeclarationKind(node); + if (assignmentKind === 6 || assignmentKind === 3) { + var symbol = getSymbolOfNode(node.left); + if (symbol && symbol.parent && !ts.findAncestor(symbol.parent.valueDeclaration, function (d) { return node === d; })) { + node = symbol.parent.valueDeclaration; + } + } + } + if (!node) { + return undefined; + } + switch (node.kind) { + case 245: + case 214: + case 246: + case 165: + case 166: + case 160: + case 170: + case 171: + case 300: + case 244: + case 161: + case 201: + case 202: + case 247: + case 320: + case 321: + case 315: + case 314: + case 186: + case 180: + var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes); + if (node.kind === 186) { + return ts.append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter))); + } + else if (node.kind === 180) { + return ts.concatenate(outerTypeParameters, getInferTypeParameters(node)); + } + var outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, ts.getEffectiveTypeParameterDeclarations(node)); + var thisType = includeThisTypes && + (node.kind === 245 || node.kind === 214 || node.kind === 246 || isJSConstructor(node)) && + getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType; + return thisType ? ts.append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters; + } + } + } + function getOuterTypeParametersOfClassOrInterface(symbol) { + var declaration = symbol.flags & 32 ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 246); + ts.Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations"); + return getOuterTypeParameters(declaration); + } + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { + var result; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var node = _a[_i]; + if (node.kind === 246 || + node.kind === 245 || + node.kind === 214 || + isJSConstructor(node) || + ts.isTypeAlias(node)) { + var declaration = node; + result = appendTypeParameters(result, ts.getEffectiveTypeParameterDeclarations(declaration)); + } + } + return result; + } + function getTypeParametersOfClassOrInterface(symbol) { + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + function isMixinConstructorType(type) { + var signatures = getSignaturesOfType(type, 1); + if (signatures.length === 1) { + var s = signatures[0]; + return !s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s) && getElementTypeOfArrayType(getTypeOfParameter(s.parameters[0])) === anyType; + } + return false; + } + function isConstructorType(type) { + if (getSignaturesOfType(type, 1).length > 0) { + return true; + } + if (type.flags & 8650752) { + var constraint = getBaseConstraintOfType(type); + return !!constraint && isMixinConstructorType(constraint); + } + return false; + } + function getBaseTypeNodeOfClass(type) { + return ts.getEffectiveBaseTypeNode(type.symbol.valueDeclaration); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes, location) { + var typeArgCount = ts.length(typeArgumentNodes); + var isJavascript = ts.isInJSFile(location); + return ts.filter(getSignaturesOfType(type, 1), function (sig) { return (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= ts.length(sig.typeParameters); }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location); + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + return ts.sameMap(signatures, function (sig) { return ts.some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, ts.isInJSFile(location)) : sig; }); + } + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var decl = type.symbol.valueDeclaration; + var extended = ts.getEffectiveBaseTypeNode(decl); + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type, 1)) { + return errorType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (extended && baseTypeNode !== extended) { + ts.Debug.assert(!extended.typeArguments); + checkExpression(extended.expression); + } + if (baseConstructorType.flags & (524288 | 2097152)) { + resolveStructuredTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = errorType; + } + if (!(baseConstructorType.flags & 1) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) { + var err = error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + if (baseConstructorType.flags & 262144) { + var constraint = getConstraintFromTypeParameter(baseConstructorType); + var ctorReturn = unknownType; + if (constraint) { + var ctorSig = getSignaturesOfType(constraint, 1); + if (ctorSig[0]) { + ctorReturn = getReturnTypeOfSignature(ctorSig[0]); + } + } + ts.addRelatedInfo(err, ts.createDiagnosticForNode(baseConstructorType.symbol.declarations[0], ts.Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn))); + } + return type.resolvedBaseConstructorType = errorType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; + } + function getBaseTypes(type) { + if (!type.resolvedBaseTypes) { + if (type.objectFlags & 8) { + type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters || ts.emptyArray), type.readonly)]; + } + else if (type.symbol.flags & (32 | 64)) { + if (type.symbol.flags & 32) { + resolveBaseTypesOfClass(type); + } + if (type.symbol.flags & 64) { + resolveBaseTypesOfInterface(type); + } + } + else { + ts.Debug.fail("type must be class or interface"); + } + } + return type.resolvedBaseTypes; + } + function resolveBaseTypesOfClass(type) { + type.resolvedBaseTypes = ts.resolvingEmptyArray; + var baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type)); + if (!(baseConstructorType.flags & (524288 | 2097152 | 1))) { + return type.resolvedBaseTypes = ts.emptyArray; + } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + var originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined; + if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 && + areAllOuterTypeParametersApplied(originalBaseType)) { + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol); + } + else if (baseConstructorType.flags & 1) { + baseType = baseConstructorType; + } + else { + var constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return type.resolvedBaseTypes = ts.emptyArray; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (baseType === errorType) { + return type.resolvedBaseTypes = ts.emptyArray; + } + if (!isValidBaseType(baseType)) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(baseType)); + return type.resolvedBaseTypes = ts.emptyArray; + } + if (type === baseType || hasBaseType(baseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2)); + return type.resolvedBaseTypes = ts.emptyArray; + } + if (type.resolvedBaseTypes === ts.resolvingEmptyArray) { + type.members = undefined; + } + return type.resolvedBaseTypes = [baseType]; + } + function areAllOuterTypeParametersApplied(type) { + var outerTypeParameters = type.outerTypeParameters; + if (outerTypeParameters) { + var last_1 = outerTypeParameters.length - 1; + var typeArguments = getTypeArguments(type); + return outerTypeParameters[last_1].symbol !== typeArguments[last_1].symbol; + } + return true; + } + function isValidBaseType(type) { + if (type.flags & 262144) { + var constraint = getBaseConstraintOfType(type); + if (constraint) { + return isValidBaseType(constraint); + } + } + return !!(type.flags & (524288 | 67108864 | 1)) && !isGenericMappedType(type) || + !!(type.flags & 2097152) && ts.every(type.types, isValidBaseType); + } + function resolveBaseTypesOfInterface(type) { + type.resolvedBaseTypes = type.resolvedBaseTypes || ts.emptyArray; + for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 246 && ts.getInterfaceBaseTypeNodes(declaration)) { + for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { + var node = _c[_b]; + var baseType = getTypeFromTypeNode(node); + if (baseType !== errorType) { + if (isValidBaseType(baseType)) { + if (type !== baseType && !hasBaseType(baseType, type)) { + if (type.resolvedBaseTypes === ts.emptyArray) { + type.resolvedBaseTypes = [baseType]; + } + else { + type.resolvedBaseTypes.push(baseType); + } + } + else { + error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2)); + } + } + else { + error(node, ts.Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members); + } + } + } + } + } + } + function isThislessInterface(symbol) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 246) { + if (declaration.flags & 128) { + return false; + } + var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration); + if (baseTypeNodes) { + for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) { + var node = baseTypeNodes_1[_b]; + if (ts.isEntityNameExpression(node.expression)) { + var baseSymbol = resolveEntityName(node.expression, 788968, true); + if (!baseSymbol || !(baseSymbol.flags & 64) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) { + return false; + } + } + } + } + } + } + return true; + } + function getDeclaredTypeOfClassOrInterface(symbol) { + var links = getSymbolLinks(symbol); + var originalLinks = links; + if (!links.declaredType) { + var kind = symbol.flags & 32 ? 1 : 2; + var merged = mergeJSSymbols(symbol, getAssignedClassSymbol(symbol.valueDeclaration)); + if (merged) { + symbol = links = merged; + } + var type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol); + var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (outerTypeParameters || localTypeParameters || kind === 1 || !isThislessInterface(symbol)) { + type.objectFlags |= 4; + type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); + type.outerTypeParameters = outerTypeParameters; + type.localTypeParameters = localTypeParameters; + type.instantiations = ts.createMap(); + type.instantiations.set(getTypeListId(type.typeParameters), type); + type.target = type; + type.resolvedTypeArguments = type.typeParameters; + type.thisType = createTypeParameter(symbol); + type.thisType.isThisType = true; + type.thisType.constraint = type; + } + } + return links.declaredType; + } + function getDeclaredTypeOfTypeAlias(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + if (!pushTypeResolution(symbol, 2)) { + return errorType; + } + var declaration = ts.Debug.assertDefined(ts.find(symbol.declarations, ts.isTypeAlias), "Type alias symbol with no valid declaration found"); + var typeNode = ts.isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type; + var type = typeNode ? getTypeFromTypeNode(typeNode) : errorType; + if (popTypeResolution()) { + var typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (typeParameters) { + links.typeParameters = typeParameters; + links.instantiations = ts.createMap(); + links.instantiations.set(getTypeListId(typeParameters), type); + } + } + else { + type = errorType; + error(ts.isNamedDeclaration(declaration) ? declaration.name : declaration || declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); + } + links.declaredType = type; + } + return links.declaredType; + } + function isStringConcatExpression(expr) { + if (ts.isStringLiteralLike(expr)) { + return true; + } + else if (expr.kind === 209) { + return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right); + } + return false; + } + function isLiteralEnumMember(member) { + var expr = member.initializer; + if (!expr) { + return !(member.flags & 8388608); + } + switch (expr.kind) { + case 10: + case 8: + case 14: + return true; + case 207: + return expr.operator === 40 && + expr.operand.kind === 8; + case 75: + return ts.nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText); + case 209: + return isStringConcatExpression(expr); + default: + return false; + } + } + function getEnumKind(symbol) { + var links = getSymbolLinks(symbol); + if (links.enumKind !== undefined) { + return links.enumKind; + } + var hasNonLiteralMember = false; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 248) { + for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) { + var member = _c[_b]; + if (member.initializer && ts.isStringLiteralLike(member.initializer)) { + return links.enumKind = 1; + } + if (!isLiteralEnumMember(member)) { + hasNonLiteralMember = true; + } + } + } + } + return links.enumKind = hasNonLiteralMember ? 0 : 1; + } + function getBaseTypeOfEnumLiteralType(type) { + return type.flags & 1024 && !(type.flags & 1048576) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type; + } + function getDeclaredTypeOfEnum(symbol) { + var links = getSymbolLinks(symbol); + if (links.declaredType) { + return links.declaredType; + } + if (getEnumKind(symbol) === 1) { + enumCount++; + var memberTypeList = []; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 248) { + for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) { + var member = _c[_b]; + var value = getEnumMemberValue(member); + var memberType = getFreshTypeOfLiteralType(getLiteralType(value !== undefined ? value : 0, enumCount, getSymbolOfNode(member))); + getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType; + memberTypeList.push(getRegularTypeOfLiteralType(memberType)); + } + } + } + if (memberTypeList.length) { + var enumType_1 = getUnionType(memberTypeList, 1, symbol, undefined); + if (enumType_1.flags & 1048576) { + enumType_1.flags |= 1024; + enumType_1.symbol = symbol; + } + return links.declaredType = enumType_1; + } + } + var enumType = createType(32); + enumType.symbol = symbol; + return links.declaredType = enumType; + } + function getDeclaredTypeOfEnumMember(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol)); + if (!links.declaredType) { + links.declaredType = enumType; + } + } + return links.declaredType; + } + function getDeclaredTypeOfTypeParameter(symbol) { + var links = getSymbolLinks(symbol); + return links.declaredType || (links.declaredType = createTypeParameter(symbol)); + } + function getDeclaredTypeOfAlias(symbol) { + var links = getSymbolLinks(symbol); + return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol))); + } + function getDeclaredTypeOfSymbol(symbol) { + return tryGetDeclaredTypeOfSymbol(symbol) || errorType; + } + function tryGetDeclaredTypeOfSymbol(symbol) { + if (symbol.flags & (32 | 64)) { + return getDeclaredTypeOfClassOrInterface(symbol); + } + if (symbol.flags & 524288) { + return getDeclaredTypeOfTypeAlias(symbol); + } + if (symbol.flags & 262144) { + return getDeclaredTypeOfTypeParameter(symbol); + } + if (symbol.flags & 384) { + return getDeclaredTypeOfEnum(symbol); + } + if (symbol.flags & 8) { + return getDeclaredTypeOfEnumMember(symbol); + } + if (symbol.flags & 2097152) { + return getDeclaredTypeOfAlias(symbol); + } + return undefined; + } + function isThislessType(node) { + switch (node.kind) { + case 125: + case 148: + case 143: + case 140: + case 151: + case 128: + case 144: + case 141: + case 110: + case 146: + case 100: + case 137: + case 187: + return true; + case 174: + return isThislessType(node.elementType); + case 169: + return !node.typeArguments || node.typeArguments.every(isThislessType); + } + return false; + } + function isThislessTypeParameter(node) { + var constraint = ts.getEffectiveConstraintOfTypeParameter(node); + return !constraint || isThislessType(constraint); + } + function isThislessVariableLikeDeclaration(node) { + var typeNode = ts.getEffectiveTypeAnnotationNode(node); + return typeNode ? isThislessType(typeNode) : !ts.hasInitializer(node); + } + function isThislessFunctionLikeDeclaration(node) { + var returnType = ts.getEffectiveReturnTypeNode(node); + var typeParameters = ts.getEffectiveTypeParameterDeclarations(node); + return (node.kind === 162 || (!!returnType && isThislessType(returnType))) && + node.parameters.every(isThislessVariableLikeDeclaration) && + typeParameters.every(isThislessTypeParameter); + } + function isThisless(symbol) { + if (symbol.declarations && symbol.declarations.length === 1) { + var declaration = symbol.declarations[0]; + if (declaration) { + switch (declaration.kind) { + case 159: + case 158: + return isThislessVariableLikeDeclaration(declaration); + case 161: + case 160: + case 162: + case 163: + case 164: + return isThislessFunctionLikeDeclaration(declaration); + } + } + } + return false; + } + function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) { + var result = ts.createSymbolTable(); + for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) { + var symbol = symbols_2[_i]; + result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper)); + } + return result; + } + function addInheritedMembers(symbols, baseSymbols) { + for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) { + var s = baseSymbols_1[_i]; + if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) { + symbols.set(s.escapedName, s); + } + } + } + function isStaticPrivateIdentifierProperty(s) { + return !!s.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(s.valueDeclaration) && ts.hasModifier(s.valueDeclaration, 32); + } + function resolveDeclaredMembers(type) { + if (!type.declaredProperties) { + var symbol = type.symbol; + var members = getMembersOfSymbol(symbol); + type.declaredProperties = getNamedMembers(members); + type.declaredCallSignatures = ts.emptyArray; + type.declaredConstructSignatures = ts.emptyArray; + type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call")); + type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new")); + type.declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, 0); + type.declaredNumberIndexInfo = getIndexInfoOfSymbol(symbol, 1); + } + return type; + } + function isTypeUsableAsPropertyName(type) { + return !!(type.flags & 8576); + } + function isLateBindableName(node) { + if (!ts.isComputedPropertyName(node) && !ts.isElementAccessExpression(node)) { + return false; + } + var expr = ts.isComputedPropertyName(node) ? node.expression : node.argumentExpression; + return ts.isEntityNameExpression(expr) + && isTypeUsableAsPropertyName(ts.isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr)); + } + function isLateBoundName(name) { + return name.charCodeAt(0) === 95 && + name.charCodeAt(1) === 95 && + name.charCodeAt(2) === 64; + } + function hasLateBindableName(node) { + var name = ts.getNameOfDeclaration(node); + return !!name && isLateBindableName(name); + } + function hasNonBindableDynamicName(node) { + return ts.hasDynamicName(node) && !hasLateBindableName(node); + } + function isNonBindableDynamicName(node) { + return ts.isDynamicName(node) && !isLateBindableName(node); + } + function getPropertyNameFromType(type) { + if (type.flags & 8192) { + return type.escapedName; + } + if (type.flags & (128 | 256)) { + return ts.escapeLeadingUnderscores("" + type.value); + } + return ts.Debug.fail(); + } + function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) { + ts.Debug.assert(!!(ts.getCheckFlags(symbol) & 4096), "Expected a late-bound symbol."); + symbol.flags |= symbolFlags; + getSymbolLinks(member.symbol).lateSymbol = symbol; + if (!symbol.declarations) { + symbol.declarations = [member]; + } + else { + symbol.declarations.push(member); + } + if (symbolFlags & 111551) { + if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) { + symbol.valueDeclaration = member; + } + } + } + function lateBindMember(parent, earlySymbols, lateSymbols, decl) { + ts.Debug.assert(!!decl.symbol, "The member is expected to have a symbol."); + var links = getNodeLinks(decl); + if (!links.resolvedSymbol) { + links.resolvedSymbol = decl.symbol; + var declName = ts.isBinaryExpression(decl) ? decl.left : decl.name; + var type = ts.isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName); + if (isTypeUsableAsPropertyName(type)) { + var memberName = getPropertyNameFromType(type); + var symbolFlags = decl.symbol.flags; + var lateSymbol = lateSymbols.get(memberName); + if (!lateSymbol) + lateSymbols.set(memberName, lateSymbol = createSymbol(0, memberName, 4096)); + var earlySymbol = earlySymbols && earlySymbols.get(memberName); + if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) { + var declarations = earlySymbol ? ts.concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations; + var name_3 = !(type.flags & 8192) && ts.unescapeLeadingUnderscores(memberName) || ts.declarationNameToString(declName); + ts.forEach(declarations, function (declaration) { return error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Property_0_was_also_declared_here, name_3); }); + error(declName || decl, ts.Diagnostics.Duplicate_property_0, name_3); + lateSymbol = createSymbol(0, memberName, 4096); + } + lateSymbol.nameType = type; + addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags); + if (lateSymbol.parent) { + ts.Debug.assert(lateSymbol.parent === parent, "Existing symbol parent should match new one"); + } + else { + lateSymbol.parent = parent; + } + return links.resolvedSymbol = lateSymbol; + } + } + return links.resolvedSymbol; + } + function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) { + var links = getSymbolLinks(symbol); + if (!links[resolutionKind]) { + var isStatic = resolutionKind === "resolvedExports"; + var earlySymbols = !isStatic ? symbol.members : + symbol.flags & 1536 ? getExportsOfModuleWorker(symbol) : + symbol.exports; + links[resolutionKind] = earlySymbols || emptySymbols; + var lateSymbols = ts.createSymbolTable(); + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var members = ts.getMembersOfDeclaration(decl); + if (members) { + for (var _b = 0, members_5 = members; _b < members_5.length; _b++) { + var member = members_5[_b]; + if (isStatic === ts.hasStaticModifier(member) && hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } + } + } + } + var assignments = symbol.assignmentDeclarationMembers; + if (assignments) { + var decls = ts.arrayFrom(assignments.values()); + for (var _c = 0, decls_1 = decls; _c < decls_1.length; _c++) { + var member = decls_1[_c]; + var assignmentKind = ts.getAssignmentDeclarationKind(member); + var isInstanceMember = assignmentKind === 3 + || assignmentKind === 4 + || assignmentKind === 9 + || assignmentKind === 6; + if (isStatic === !isInstanceMember && hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } + } + } + links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols; + } + return links[resolutionKind]; + } + function getMembersOfSymbol(symbol) { + return symbol.flags & 6256 + ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers") + : symbol.members || emptySymbols; + } + function getLateBoundSymbol(symbol) { + if (symbol.flags & 106500 && symbol.escapedName === "__computed") { + var links = getSymbolLinks(symbol); + if (!links.lateSymbol && ts.some(symbol.declarations, hasLateBindableName)) { + var parent = getMergedSymbol(symbol.parent); + if (ts.some(symbol.declarations, ts.hasStaticModifier)) { + getExportsOfSymbol(parent); + } + else { + getMembersOfSymbol(parent); + } + } + return links.lateSymbol || (links.lateSymbol = symbol); + } + return symbol; + } + function getTypeWithThisArgument(type, thisArgument, needApparentType) { + if (ts.getObjectFlags(type) & 4) { + var target = type.target; + var typeArguments = getTypeArguments(type); + if (ts.length(target.typeParameters) === ts.length(typeArguments)) { + var ref = createTypeReference(target, ts.concatenate(typeArguments, [thisArgument || target.thisType])); + return needApparentType ? getApparentType(ref) : ref; + } + } + else if (type.flags & 2097152) { + return getIntersectionType(ts.map(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); })); + } + return needApparentType ? getApparentType(type) : type; + } + function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) { + var mapper; + var members; + var callSignatures; + var constructSignatures; + var stringIndexInfo; + var numberIndexInfo; + if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) { + mapper = identityMapper; + members = source.symbol ? getMembersOfSymbol(source.symbol) : ts.createSymbolTable(source.declaredProperties); + callSignatures = source.declaredCallSignatures; + constructSignatures = source.declaredConstructSignatures; + stringIndexInfo = source.declaredStringIndexInfo; + numberIndexInfo = source.declaredNumberIndexInfo; + } + else { + mapper = createTypeMapper(typeParameters, typeArguments); + members = createInstantiatedSymbolTable(source.declaredProperties, mapper, typeParameters.length === 1); + callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper); + constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper); + stringIndexInfo = instantiateIndexInfo(source.declaredStringIndexInfo, mapper); + numberIndexInfo = instantiateIndexInfo(source.declaredNumberIndexInfo, mapper); + } + var baseTypes = getBaseTypes(source); + if (baseTypes.length) { + if (source.symbol && members === getMembersOfSymbol(source.symbol)) { + members = ts.createSymbolTable(source.declaredProperties); + } + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + var thisArgument = ts.lastOrUndefined(typeArguments); + for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) { + var baseType = baseTypes_1[_i]; + var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType; + addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType)); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1)); + if (!stringIndexInfo) { + stringIndexInfo = instantiatedBaseType === anyType ? + createIndexInfo(anyType, false) : + getIndexInfoOfType(instantiatedBaseType, 0); + } + numberIndexInfo = numberIndexInfo || getIndexInfoOfType(instantiatedBaseType, 1); + } + } + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + } + function resolveClassOrInterfaceMembers(type) { + resolveObjectTypeMembers(type, resolveDeclaredMembers(type), ts.emptyArray, ts.emptyArray); + } + function resolveTypeReferenceMembers(type) { + var source = resolveDeclaredMembers(type.target); + var typeParameters = ts.concatenate(source.typeParameters, [source.thisType]); + var typeArguments = getTypeArguments(type); + var paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : ts.concatenate(typeArguments, [type]); + resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments); + } + function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) { + var sig = new Signature(checker, flags); + sig.declaration = declaration; + sig.typeParameters = typeParameters; + sig.parameters = parameters; + sig.thisParameter = thisParameter; + sig.resolvedReturnType = resolvedReturnType; + sig.resolvedTypePredicate = resolvedTypePredicate; + sig.minArgumentCount = minArgumentCount; + sig.target = undefined; + sig.mapper = undefined; + sig.unionSignatures = undefined; + return sig; + } + function cloneSignature(sig) { + var result = createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, undefined, undefined, sig.minArgumentCount, sig.flags & 3); + result.target = sig.target; + result.mapper = sig.mapper; + result.unionSignatures = sig.unionSignatures; + return result; + } + function createUnionSignature(signature, unionSignatures) { + var result = cloneSignature(signature); + result.unionSignatures = unionSignatures; + result.target = undefined; + result.mapper = undefined; + return result; + } + function getOptionalCallSignature(signature, callChainFlags) { + if ((signature.flags & 12) === callChainFlags) { + return signature; + } + if (!signature.optionalCallSignatureCache) { + signature.optionalCallSignatureCache = {}; + } + var key = callChainFlags === 4 ? "inner" : "outer"; + return signature.optionalCallSignatureCache[key] + || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags)); + } + function createOptionalCallSignature(signature, callChainFlags) { + ts.Debug.assert(callChainFlags === 4 || callChainFlags === 8, "An optional call signature can either be for an inner call chain or an outer call chain, but not both."); + var result = cloneSignature(signature); + result.flags |= callChainFlags; + return result; + } + function getExpandedParameters(sig) { + if (signatureHasRestParameter(sig)) { + var restIndex_1 = sig.parameters.length - 1; + var restParameter = sig.parameters[restIndex_1]; + var restType = getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + var elementTypes = getTypeArguments(restType); + var minLength_1 = restType.target.minLength; + var tupleRestIndex_1 = restType.target.hasRestElement ? elementTypes.length - 1 : -1; + var restParams = ts.map(elementTypes, function (t, i) { + var name = getParameterNameAtPosition(sig, restIndex_1 + i); + var checkFlags = i === tupleRestIndex_1 ? 32768 : + i >= minLength_1 ? 16384 : 0; + var symbol = createSymbol(1, name, checkFlags); + symbol.type = i === tupleRestIndex_1 ? createArrayType(t) : t; + return symbol; + }); + return ts.concatenate(sig.parameters.slice(0, restIndex_1), restParams); + } + } + return sig.parameters; + } + function getDefaultConstructSignatures(classType) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1); + if (baseSignatures.length === 0) { + return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, undefined, 0, 0)]; + } + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var isJavaScript = ts.isInJSFile(baseTypeNode); + var typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode); + var typeArgCount = ts.length(typeArguments); + var result = []; + for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) { + var baseSig = baseSignatures_1[_i]; + var minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters); + var typeParamCount = ts.length(baseSig.typeParameters); + if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) { + var sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + result.push(sig); + } + } + return result; + } + function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) { + for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) { + var s = signatureList_1[_i]; + if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) { + return s; + } + } + } + function findMatchingSignatures(signatureLists, signature, listIndex) { + if (signature.typeParameters) { + if (listIndex > 0) { + return undefined; + } + for (var i = 1; i < signatureLists.length; i++) { + if (!findMatchingSignature(signatureLists[i], signature, false, false, false)) { + return undefined; + } + } + return [signature]; + } + var result; + for (var i = 0; i < signatureLists.length; i++) { + var match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, true, false, true); + if (!match) { + return undefined; + } + result = ts.appendIfUnique(result, match); + } + return result; + } + function getUnionSignatures(signatureLists) { + var result; + var indexWithLengthOverOne; + for (var i = 0; i < signatureLists.length; i++) { + if (signatureLists[i].length === 0) + return ts.emptyArray; + if (signatureLists[i].length > 1) { + indexWithLengthOverOne = indexWithLengthOverOne === undefined ? i : -1; + } + for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) { + var signature = _a[_i]; + if (!result || !findMatchingSignature(result, signature, false, false, true)) { + var unionSignatures = findMatchingSignatures(signatureLists, signature, i); + if (unionSignatures) { + var s = signature; + if (unionSignatures.length > 1) { + var thisParameter = signature.thisParameter; + var firstThisParameterOfUnionSignatures = ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; }); + if (firstThisParameterOfUnionSignatures) { + var thisType = getIntersectionType(ts.mapDefined(unionSignatures, function (sig) { return sig.thisParameter && getTypeOfSymbol(sig.thisParameter); })); + thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType); + } + s = createUnionSignature(signature, unionSignatures); + s.thisParameter = thisParameter; + } + (result || (result = [])).push(s); + } + } + } + } + if (!ts.length(result) && indexWithLengthOverOne !== -1) { + var masterList = signatureLists[indexWithLengthOverOne !== undefined ? indexWithLengthOverOne : 0]; + var results = masterList.slice(); + var _loop_8 = function (signatures) { + if (signatures !== masterList) { + var signature_1 = signatures[0]; + ts.Debug.assert(!!signature_1, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass"); + results = signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters; }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); }); + if (!results) { + return "break"; + } + } + }; + for (var _b = 0, signatureLists_1 = signatureLists; _b < signatureLists_1.length; _b++) { + var signatures = signatureLists_1[_b]; + var state_3 = _loop_8(signatures); + if (state_3 === "break") + break; + } + result = results; + } + return result || ts.emptyArray; + } + function combineUnionThisParam(left, right) { + if (!left || !right) { + return left || right; + } + var thisType = getIntersectionType([getTypeOfSymbol(left), getTypeOfSymbol(right)]); + return createSymbolWithType(left, thisType); + } + function combineUnionParameters(left, right) { + var leftCount = getParameterCount(left); + var rightCount = getParameterCount(right); + var longest = leftCount >= rightCount ? left : right; + var shorter = longest === left ? right : left; + var longestCount = longest === left ? leftCount : rightCount; + var eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right)); + var needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest); + var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0)); + for (var i = 0; i < longestCount; i++) { + var longestParamType = tryGetTypeAtPosition(longest, i); + var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType; + var unionParamType = getIntersectionType([longestParamType, shorterParamType]); + var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1); + var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter); + var leftName = i >= leftCount ? undefined : getParameterNameAtPosition(left, i); + var rightName = i >= rightCount ? undefined : getParameterNameAtPosition(right, i); + var paramName = leftName === rightName ? leftName : + !leftName ? rightName : + !rightName ? leftName : + undefined; + var paramSymbol = createSymbol(1 | (isOptional && !isRestParam ? 16777216 : 0), paramName || "arg" + i); + paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType; + params[i] = paramSymbol; + } + if (needsExtraRestElement) { + var restParamSymbol = createSymbol(1, "args"); + restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount)); + params[longestCount] = restParamSymbol; + } + return params; + } + function combineSignaturesOfUnionMembers(left, right) { + var declaration = left.declaration; + var params = combineUnionParameters(left, right); + var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter); + var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); + var result = createSignature(declaration, left.typeParameters || right.typeParameters, thisParam, params, undefined, undefined, minArgCount, (left.flags | right.flags) & 3); + result.unionSignatures = ts.concatenate(left.unionSignatures || [left], [right]); + return result; + } + function getUnionIndexInfo(types, kind) { + var indexTypes = []; + var isAnyReadonly = false; + for (var _i = 0, types_2 = types; _i < types_2.length; _i++) { + var type = types_2[_i]; + var indexInfo = getIndexInfoOfType(type, kind); + if (!indexInfo) { + return undefined; + } + indexTypes.push(indexInfo.type); + isAnyReadonly = isAnyReadonly || indexInfo.isReadonly; + } + return createIndexInfo(getUnionType(indexTypes, 2), isAnyReadonly); + } + function resolveUnionTypeMembers(type) { + var callSignatures = getUnionSignatures(ts.map(type.types, function (t) { return t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0); })); + var constructSignatures = getUnionSignatures(ts.map(type.types, function (t) { return getSignaturesOfType(t, 1); })); + var stringIndexInfo = getUnionIndexInfo(type.types, 0); + var numberIndexInfo = getUnionIndexInfo(type.types, 1); + setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + } + function intersectTypes(type1, type2) { + return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]); + } + function intersectIndexInfos(info1, info2) { + return !info1 ? info2 : !info2 ? info1 : createIndexInfo(getIntersectionType([info1.type, info2.type]), info1.isReadonly && info2.isReadonly); + } + function unionSpreadIndexInfos(info1, info2) { + return info1 && info2 && createIndexInfo(getUnionType([info1.type, info2.type]), info1.isReadonly || info2.isReadonly); + } + function findMixins(types) { + var constructorTypeCount = ts.countWhere(types, function (t) { return getSignaturesOfType(t, 1).length > 0; }); + var mixinFlags = ts.map(types, isMixinConstructorType); + if (constructorTypeCount > 0 && constructorTypeCount === ts.countWhere(mixinFlags, function (b) { return b; })) { + var firstMixinIndex = mixinFlags.indexOf(true); + mixinFlags[firstMixinIndex] = false; + } + return mixinFlags; + } + function includeMixinType(type, types, mixinFlags, index) { + var mixedTypes = []; + for (var i = 0; i < types.length; i++) { + if (i === index) { + mixedTypes.push(type); + } + else if (mixinFlags[i]) { + mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1)[0])); + } + } + return getIntersectionType(mixedTypes); + } + function resolveIntersectionTypeMembers(type) { + var callSignatures; + var constructSignatures; + var stringIndexInfo; + var numberIndexInfo; + var types = type.types; + var mixinFlags = findMixins(types); + var mixinCount = ts.countWhere(mixinFlags, function (b) { return b; }); + var _loop_9 = function (i) { + var t = type.types[i]; + if (!mixinFlags[i]) { + var signatures = getSignaturesOfType(t, 1); + if (signatures.length && mixinCount > 0) { + signatures = ts.map(signatures, function (s) { + var clone = cloneSignature(s); + clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i); + return clone; + }); + } + constructSignatures = appendSignatures(constructSignatures, signatures); + } + callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0)); + stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, 0)); + numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, 1)); + }; + for (var i = 0; i < types.length; i++) { + _loop_9(i); + } + setStructuredTypeMembers(type, emptySymbols, callSignatures || ts.emptyArray, constructSignatures || ts.emptyArray, stringIndexInfo, numberIndexInfo); + } + function appendSignatures(signatures, newSignatures) { + var _loop_10 = function (sig) { + if (!signatures || ts.every(signatures, function (s) { return !compareSignaturesIdentical(s, sig, false, false, false, compareTypesIdentical); })) { + signatures = ts.append(signatures, sig); + } + }; + for (var _i = 0, newSignatures_1 = newSignatures; _i < newSignatures_1.length; _i++) { + var sig = newSignatures_1[_i]; + _loop_10(sig); + } + return signatures; + } + function resolveAnonymousTypeMembers(type) { + var symbol = getMergedSymbol(type.symbol); + if (type.target) { + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, false); + var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0), type.mapper); + var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1), type.mapper); + var stringIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 0), type.mapper); + var numberIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 1), type.mapper); + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + } + else if (symbol.flags & 2048) { + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var members = getMembersOfSymbol(symbol); + var callSignatures = getSignaturesOfSymbol(members.get("__call")); + var constructSignatures = getSignaturesOfSymbol(members.get("__new")); + var stringIndexInfo = getIndexInfoOfSymbol(symbol, 0); + var numberIndexInfo = getIndexInfoOfSymbol(symbol, 1); + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + } + else { + var members = emptySymbols; + var stringIndexInfo = void 0; + if (symbol.exports) { + members = getExportsOfSymbol(symbol); + if (symbol === globalThisSymbol) { + var varsOnly_1 = ts.createMap(); + members.forEach(function (p) { + if (!(p.flags & 418)) { + varsOnly_1.set(p.escapedName, p); + } + }); + members = varsOnly_1; + } + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, undefined, undefined); + if (symbol.flags & 32) { + var classType = getDeclaredTypeOfClassOrInterface(symbol); + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & (524288 | 2097152 | 8650752)) { + members = ts.createSymbolTable(getNamedMembers(members)); + addInheritedMembers(members, getPropertiesOfType(baseConstructorType)); + } + else if (baseConstructorType === anyType) { + stringIndexInfo = createIndexInfo(anyType, false); + } + } + var numberIndexInfo = symbol.flags & 384 && (getDeclaredTypeOfSymbol(symbol).flags & 32 || + ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296); })) ? enumNumberIndexInfo : undefined; + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo); + if (symbol.flags & (16 | 8192)) { + type.callSignatures = getSignaturesOfSymbol(symbol); + } + if (symbol.flags & 32) { + var classType_1 = getDeclaredTypeOfClassOrInterface(symbol); + var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor")) : ts.emptyArray; + if (symbol.flags & 16) { + constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ? + createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, undefined, sig.minArgumentCount, sig.flags & 3) : + undefined; })); + } + if (!constructSignatures.length) { + constructSignatures = getDefaultConstructSignatures(classType_1); + } + type.constructSignatures = constructSignatures; + } + } + } + function resolveReverseMappedTypeMembers(type) { + var indexInfo = getIndexInfoOfType(type.source, 0); + var modifiers = getMappedTypeModifiers(type.mappedType); + var readonlyMask = modifiers & 1 ? false : true; + var optionalMask = modifiers & 4 ? 0 : 16777216; + var stringIndexInfo = indexInfo && createIndexInfo(inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly); + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfType(type.source); _i < _a.length; _i++) { + var prop = _a[_i]; + var checkFlags = 8192 | (readonlyMask && isReadonlySymbol(prop) ? 8 : 0); + var inferredProp = createSymbol(4 | prop.flags & optionalMask, prop.escapedName, checkFlags); + inferredProp.declarations = prop.declarations; + inferredProp.nameType = getSymbolLinks(prop).nameType; + inferredProp.propertyType = getTypeOfSymbol(prop); + inferredProp.mappedType = type.mappedType; + inferredProp.constraintType = type.constraintType; + members.set(prop.escapedName, inferredProp); + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined); + } + function getLowerBoundOfKeyType(type) { + if (type.flags & (1 | 131068)) { + return type; + } + if (type.flags & 4194304) { + return getIndexType(getApparentType(type.type)); + } + if (type.flags & 16777216) { + if (type.root.isDistributive) { + var checkType = type.checkType; + var constraint = getLowerBoundOfKeyType(checkType); + if (constraint !== checkType) { + var mapper = makeUnaryTypeMapper(type.root.checkType, constraint); + return getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper)); + } + } + return type; + } + if (type.flags & 1048576) { + return getUnionType(ts.sameMap(type.types, getLowerBoundOfKeyType)); + } + if (type.flags & 2097152) { + return getIntersectionType(ts.sameMap(type.types, getLowerBoundOfKeyType)); + } + return neverType; + } + function resolveMappedTypeMembers(type) { + var members = ts.createSymbolTable(); + var stringIndexInfo; + var numberIndexInfo; + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + var typeParameter = getTypeParameterFromMappedType(type); + var constraintType = getConstraintTypeFromMappedType(type); + var templateType = getTemplateTypeFromMappedType(type.target || type); + var modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); + var templateModifiers = getMappedTypeModifiers(type); + var include = keyofStringsOnly ? 128 : 8576; + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + for (var _i = 0, _a = getPropertiesOfType(modifiersType); _i < _a.length; _i++) { + var prop = _a[_i]; + addMemberForKeyType(getLiteralTypeFromProperty(prop, include)); + } + if (modifiersType.flags & 1 || getIndexInfoOfType(modifiersType, 0)) { + addMemberForKeyType(stringType); + } + if (!keyofStringsOnly && getIndexInfoOfType(modifiersType, 1)) { + addMemberForKeyType(numberType); + } + } + else { + forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType); + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo); + function addMemberForKeyType(t) { + var templateMapper = combineTypeMappers(type.mapper, createTypeMapper([typeParameter], [t])); + var propType = instantiateType(templateType, templateMapper); + if (isTypeUsableAsPropertyName(t)) { + var propName = getPropertyNameFromType(t); + var modifiersProp = getPropertyOfType(modifiersType, propName); + var isOptional = !!(templateModifiers & 4 || + !(templateModifiers & 8) && modifiersProp && modifiersProp.flags & 16777216); + var isReadonly = !!(templateModifiers & 1 || + !(templateModifiers & 2) && modifiersProp && isReadonlySymbol(modifiersProp)); + var prop = createSymbol(4 | (isOptional ? 16777216 : 0), propName, isReadonly ? 8 : 0); + prop.type = strictNullChecks && isOptional && !isTypeAssignableTo(undefinedType, propType) ? getOptionalType(propType) : + strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 ? getTypeWithFacts(propType, 524288) : + propType; + if (modifiersProp) { + prop.syntheticOrigin = modifiersProp; + prop.declarations = modifiersProp.declarations; + } + prop.nameType = t; + members.set(propName, prop); + } + else if (t.flags & (1 | 4)) { + stringIndexInfo = createIndexInfo(propType, !!(templateModifiers & 1)); + } + else if (t.flags & (8 | 32)) { + numberIndexInfo = createIndexInfo(numberIndexInfo ? getUnionType([numberIndexInfo.type, propType]) : propType, !!(templateModifiers & 1)); + } + } + } + function getTypeParameterFromMappedType(type) { + return type.typeParameter || + (type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter))); + } + function getConstraintTypeFromMappedType(type) { + return type.constraintType || + (type.constraintType = getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)) || errorType); + } + function getTemplateTypeFromMappedType(type) { + return type.templateType || + (type.templateType = type.declaration.type ? + instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), !!(getMappedTypeModifiers(type) & 4)), type.mapper || identityMapper) : + errorType); + } + function getConstraintDeclarationForMappedType(type) { + return ts.getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter); + } + function isMappedTypeWithKeyofConstraintDeclaration(type) { + var constraintDeclaration = getConstraintDeclarationForMappedType(type); + return constraintDeclaration.kind === 184 && + constraintDeclaration.operator === 134; + } + function getModifiersTypeFromMappedType(type) { + if (!type.modifiersType) { + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper || identityMapper); + } + else { + var declaredType = getTypeFromMappedTypeNode(type.declaration); + var constraint = getConstraintTypeFromMappedType(declaredType); + var extendedConstraint = constraint && constraint.flags & 262144 ? getConstraintOfTypeParameter(constraint) : constraint; + type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 ? instantiateType(extendedConstraint.type, type.mapper || identityMapper) : unknownType; + } + } + return type.modifiersType; + } + function getMappedTypeModifiers(type) { + var declaration = type.declaration; + return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 ? 2 : 1 : 0) | + (declaration.questionToken ? declaration.questionToken.kind === 40 ? 8 : 4 : 0); + } + function getMappedTypeOptionality(type) { + var modifiers = getMappedTypeModifiers(type); + return modifiers & 8 ? -1 : modifiers & 4 ? 1 : 0; + } + function getCombinedMappedTypeOptionality(type) { + var optionality = getMappedTypeOptionality(type); + var modifiersType = getModifiersTypeFromMappedType(type); + return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0); + } + function isPartialMappedType(type) { + return !!(ts.getObjectFlags(type) & 32 && getMappedTypeModifiers(type) & 4); + } + function isGenericMappedType(type) { + return !!(ts.getObjectFlags(type) & 32) && isGenericIndexType(getConstraintTypeFromMappedType(type)); + } + function resolveStructuredTypeMembers(type) { + if (!type.members) { + if (type.flags & 524288) { + if (type.objectFlags & 4) { + resolveTypeReferenceMembers(type); + } + else if (type.objectFlags & 3) { + resolveClassOrInterfaceMembers(type); + } + else if (type.objectFlags & 2048) { + resolveReverseMappedTypeMembers(type); + } + else if (type.objectFlags & 16) { + resolveAnonymousTypeMembers(type); + } + else if (type.objectFlags & 32) { + resolveMappedTypeMembers(type); + } + } + else if (type.flags & 1048576) { + resolveUnionTypeMembers(type); + } + else if (type.flags & 2097152) { + resolveIntersectionTypeMembers(type); + } + } + return type; + } + function getPropertiesOfObjectType(type) { + if (type.flags & 524288) { + return resolveStructuredTypeMembers(type).properties; + } + return ts.emptyArray; + } + function getPropertyOfObjectType(type, name) { + if (type.flags & 524288) { + var resolved = resolveStructuredTypeMembers(type); + var symbol = resolved.members.get(name); + if (symbol && symbolIsValue(symbol)) { + return symbol; + } + } + } + function getPropertiesOfUnionOrIntersectionType(type) { + if (!type.resolvedProperties) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var current = _a[_i]; + for (var _b = 0, _c = getPropertiesOfType(current); _b < _c.length; _b++) { + var prop = _c[_b]; + if (!members.has(prop.escapedName)) { + var combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName); + if (combinedProp) { + members.set(prop.escapedName, combinedProp); + } + } + } + if (type.flags & 1048576) { + break; + } + } + type.resolvedProperties = getNamedMembers(members); + } + return type.resolvedProperties; + } + function getPropertiesOfType(type) { + type = getApparentType(type); + return type.flags & 3145728 ? + getPropertiesOfUnionOrIntersectionType(type) : + getPropertiesOfObjectType(type); + } + function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) { + var list = obj.properties; + return list.some(function (property) { + var nameType = property.name && getLiteralTypeFromPropertyName(property.name); + var name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined; + var expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name); + return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected); + }); + } + function getAllPossiblePropertiesOfTypes(types) { + var unionType = getUnionType(types); + if (!(unionType.flags & 1048576)) { + return getAugmentedPropertiesOfType(unionType); + } + var props = ts.createSymbolTable(); + for (var _i = 0, types_3 = types; _i < types_3.length; _i++) { + var memberType = types_3[_i]; + for (var _a = 0, _b = getAugmentedPropertiesOfType(memberType); _a < _b.length; _a++) { + var escapedName = _b[_a].escapedName; + if (!props.has(escapedName)) { + var prop = createUnionOrIntersectionProperty(unionType, escapedName); + if (prop) + props.set(escapedName, prop); + } + } + } + return ts.arrayFrom(props.values()); + } + function getConstraintOfType(type) { + return type.flags & 262144 ? getConstraintOfTypeParameter(type) : + type.flags & 8388608 ? getConstraintOfIndexedAccess(type) : + type.flags & 16777216 ? getConstraintOfConditionalType(type) : + getBaseConstraintOfType(type); + } + function getConstraintOfTypeParameter(typeParameter) { + return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined; + } + function getConstraintOfIndexedAccess(type) { + return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : undefined; + } + function getSimplifiedTypeOrConstraint(type) { + var simplified = getSimplifiedType(type, false); + return simplified !== type ? simplified : getConstraintOfType(type); + } + function getConstraintFromIndexedAccess(type) { + var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType); + if (indexConstraint && indexConstraint !== type.indexType) { + var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint); + if (indexedAccess) { + return indexedAccess; + } + } + var objectConstraint = getSimplifiedTypeOrConstraint(type.objectType); + if (objectConstraint && objectConstraint !== type.objectType) { + return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType); + } + return undefined; + } + function getDefaultConstraintOfConditionalType(type) { + if (!type.resolvedDefaultConstraint) { + var trueConstraint = getInferredTrueTypeFromConditionalType(type); + var falseConstraint = getFalseTypeFromConditionalType(type); + type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]); + } + return type.resolvedDefaultConstraint; + } + function getConstraintOfDistributiveConditionalType(type) { + if (type.root.isDistributive && type.restrictiveInstantiation !== type) { + var simplified = getSimplifiedType(type.checkType, false); + var constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified; + if (constraint && constraint !== type.checkType) { + var mapper = makeUnaryTypeMapper(type.root.checkType, constraint); + var instantiated = getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper)); + if (!(instantiated.flags & 131072)) { + return instantiated; + } + } + } + return undefined; + } + function getConstraintFromConditionalType(type) { + return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type); + } + function getConstraintOfConditionalType(type) { + return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : undefined; + } + function getEffectiveConstraintOfIntersection(types, targetIsUnion) { + var constraints; + var hasDisjointDomainType = false; + for (var _i = 0, types_4 = types; _i < types_4.length; _i++) { + var t = types_4[_i]; + if (t.flags & 63176704) { + var constraint = getConstraintOfType(t); + while (constraint && constraint.flags & (262144 | 4194304 | 16777216)) { + constraint = getConstraintOfType(constraint); + } + if (constraint) { + constraints = ts.append(constraints, constraint); + if (targetIsUnion) { + constraints = ts.append(constraints, t); + } + } + } + else if (t.flags & 67238908) { + hasDisjointDomainType = true; + } + } + if (constraints && (targetIsUnion || hasDisjointDomainType)) { + if (hasDisjointDomainType) { + for (var _a = 0, types_5 = types; _a < types_5.length; _a++) { + var t = types_5[_a]; + if (t.flags & 67238908) { + constraints = ts.append(constraints, t); + } + } + } + return getIntersectionType(constraints); + } + return undefined; + } + function getBaseConstraintOfType(type) { + if (type.flags & (58982400 | 3145728)) { + var constraint = getResolvedBaseConstraint(type); + return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined; + } + return type.flags & 4194304 ? keyofConstraintType : undefined; + } + function getBaseConstraintOrType(type) { + return getBaseConstraintOfType(type) || type; + } + function hasNonCircularBaseConstraint(type) { + return getResolvedBaseConstraint(type) !== circularConstraintType; + } + function getResolvedBaseConstraint(type) { + var nonTerminating = false; + return type.resolvedBaseConstraint || + (type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type)); + function getImmediateBaseConstraint(t) { + if (!t.immediateBaseConstraint) { + if (!pushTypeResolution(t, 4)) { + return circularConstraintType; + } + if (constraintDepth >= 50) { + error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); + nonTerminating = true; + return t.immediateBaseConstraint = noConstraintType; + } + constraintDepth++; + var result = computeBaseConstraint(getSimplifiedType(t, false)); + constraintDepth--; + if (!popTypeResolution()) { + if (t.flags & 262144) { + var errorNode = getConstraintDeclaration(t); + if (errorNode) { + var diagnostic = error(errorNode, ts.Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t)); + if (currentNode && !ts.isNodeDescendantOf(errorNode, currentNode) && !ts.isNodeDescendantOf(currentNode, errorNode)) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(currentNode, ts.Diagnostics.Circularity_originates_in_type_at_this_location)); + } + } + } + result = circularConstraintType; + } + if (nonTerminating) { + result = circularConstraintType; + } + t.immediateBaseConstraint = result || noConstraintType; + } + return t.immediateBaseConstraint; + } + function getBaseConstraint(t) { + var c = getImmediateBaseConstraint(t); + return c !== noConstraintType && c !== circularConstraintType ? c : undefined; + } + function computeBaseConstraint(t) { + if (t.flags & 262144) { + var constraint = getConstraintFromTypeParameter(t); + return t.isThisType || !constraint ? + constraint : + getBaseConstraint(constraint); + } + if (t.flags & 3145728) { + var types = t.types; + var baseTypes = []; + for (var _i = 0, types_6 = types; _i < types_6.length; _i++) { + var type_2 = types_6[_i]; + var baseType = getBaseConstraint(type_2); + if (baseType) { + baseTypes.push(baseType); + } + } + return t.flags & 1048576 && baseTypes.length === types.length ? getUnionType(baseTypes) : + t.flags & 2097152 && baseTypes.length ? getIntersectionType(baseTypes) : + undefined; + } + if (t.flags & 4194304) { + return keyofConstraintType; + } + if (t.flags & 8388608) { + var baseObjectType = getBaseConstraint(t.objectType); + var baseIndexType = getBaseConstraint(t.indexType); + var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType); + return baseIndexedAccess && getBaseConstraint(baseIndexedAccess); + } + if (t.flags & 16777216) { + var constraint = getConstraintFromConditionalType(t); + constraintDepth++; + var result = constraint && getBaseConstraint(constraint); + constraintDepth--; + return result; + } + if (t.flags & 33554432) { + return getBaseConstraint(t.substitute); + } + return t; + } + } + function getApparentTypeOfIntersectionType(type) { + return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, true)); + } + function getResolvedTypeParameterDefault(typeParameter) { + if (!typeParameter.default) { + if (typeParameter.target) { + var targetDefault = getResolvedTypeParameterDefault(typeParameter.target); + typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType; + } + else { + typeParameter.default = resolvingDefaultType; + var defaultDeclaration = typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; }); + var defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType; + if (typeParameter.default === resolvingDefaultType) { + typeParameter.default = defaultType; + } + } + } + else if (typeParameter.default === resolvingDefaultType) { + typeParameter.default = circularConstraintType; + } + return typeParameter.default; + } + function getDefaultFromTypeParameter(typeParameter) { + var defaultType = getResolvedTypeParameterDefault(typeParameter); + return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : undefined; + } + function hasNonCircularTypeParameterDefault(typeParameter) { + return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType; + } + function hasTypeParameterDefault(typeParameter) { + return !!(typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; })); + } + function getApparentTypeOfMappedType(type) { + return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type)); + } + function getResolvedApparentTypeOfMappedType(type) { + var typeVariable = getHomomorphicTypeVariable(type); + if (typeVariable) { + var constraint = getConstraintOfTypeParameter(typeVariable); + if (constraint && (isArrayType(constraint) || isTupleType(constraint))) { + var mapper = makeUnaryTypeMapper(typeVariable, constraint); + return instantiateType(type, combineTypeMappers(mapper, type.mapper)); + } + } + return type; + } + function getApparentType(type) { + var t = type.flags & 63176704 ? getBaseConstraintOfType(type) || unknownType : type; + return ts.getObjectFlags(t) & 32 ? getApparentTypeOfMappedType(t) : + t.flags & 2097152 ? getApparentTypeOfIntersectionType(t) : + t.flags & 132 ? globalStringType : + t.flags & 296 ? globalNumberType : + t.flags & 2112 ? getGlobalBigIntType(languageVersion >= 99) : + t.flags & 528 ? globalBooleanType : + t.flags & 12288 ? getGlobalESSymbolType(languageVersion >= 2) : + t.flags & 67108864 ? emptyObjectType : + t.flags & 4194304 ? keyofConstraintType : + t.flags & 2 && !strictNullChecks ? emptyObjectType : + t; + } + function createUnionOrIntersectionProperty(containingType, name) { + var propSet = ts.createMap(); + var indexTypes; + var isUnion = containingType.flags & 1048576; + var excludeModifiers = isUnion ? 24 : 0; + var optionalFlag = isUnion ? 0 : 16777216; + var syntheticFlag = 4; + var checkFlags = 0; + for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) { + var current = _a[_i]; + var type = getApparentType(current); + if (type !== errorType) { + var prop = getPropertyOfType(type, name); + var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0; + if (prop && !(modifiers & excludeModifiers)) { + if (isUnion) { + optionalFlag |= (prop.flags & 16777216); + } + else { + optionalFlag &= prop.flags; + } + var id = "" + getSymbolId(prop); + if (!propSet.has(id)) { + propSet.set(id, prop); + } + checkFlags |= (isReadonlySymbol(prop) ? 8 : 0) | + (!(modifiers & 24) ? 256 : 0) | + (modifiers & 16 ? 512 : 0) | + (modifiers & 8 ? 1024 : 0) | + (modifiers & 32 ? 2048 : 0); + if (!isPrototypeProperty(prop)) { + syntheticFlag = 2; + } + } + else if (isUnion) { + var indexInfo = !isLateBoundName(name) && (isNumericLiteralName(name) && getIndexInfoOfType(type, 1) || getIndexInfoOfType(type, 0)); + if (indexInfo) { + checkFlags |= 32 | (indexInfo.isReadonly ? 8 : 0); + indexTypes = ts.append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type); + } + else if (isObjectLiteralType(type)) { + checkFlags |= 32; + indexTypes = ts.append(indexTypes, undefinedType); + } + else { + checkFlags |= 16; + } + } + } + } + if (!propSet.size) { + return undefined; + } + var props = ts.arrayFrom(propSet.values()); + if (props.length === 1 && !(checkFlags & 16) && !indexTypes) { + return props[0]; + } + var declarations; + var firstType; + var nameType; + var propTypes = []; + var firstValueDeclaration; + var hasNonUniformValueDeclaration = false; + for (var _b = 0, props_1 = props; _b < props_1.length; _b++) { + var prop = props_1[_b]; + if (!firstValueDeclaration) { + firstValueDeclaration = prop.valueDeclaration; + } + else if (prop.valueDeclaration !== firstValueDeclaration) { + hasNonUniformValueDeclaration = true; + } + declarations = ts.addRange(declarations, prop.declarations); + var type = getTypeOfSymbol(prop); + if (!firstType) { + firstType = type; + nameType = getSymbolLinks(prop).nameType; + } + else if (type !== firstType) { + checkFlags |= 64; + } + if (isLiteralType(type)) { + checkFlags |= 128; + } + propTypes.push(type); + } + ts.addRange(propTypes, indexTypes); + var result = createSymbol(4 | optionalFlag, name, syntheticFlag | checkFlags); + result.containingType = containingType; + if (!hasNonUniformValueDeclaration && firstValueDeclaration) { + result.valueDeclaration = firstValueDeclaration; + if (firstValueDeclaration.symbol.parent) { + result.parent = firstValueDeclaration.symbol.parent; + } + } + result.declarations = declarations; + result.nameType = nameType; + if (propTypes.length > 2) { + result.checkFlags |= 65536; + result.deferralParent = containingType; + result.deferralConstituents = propTypes; + } + else { + result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes); + } + return result; + } + function getUnionOrIntersectionProperty(type, name) { + var properties = type.propertyCache || (type.propertyCache = ts.createSymbolTable()); + var property = properties.get(name); + if (!property) { + property = createUnionOrIntersectionProperty(type, name); + if (property) { + properties.set(name, property); + } + } + return property; + } + function getPropertyOfUnionOrIntersectionType(type, name) { + var property = getUnionOrIntersectionProperty(type, name); + return property && !(ts.getCheckFlags(property) & 16) ? property : undefined; + } + function getPropertyOfType(type, name) { + type = getApparentType(type); + if (type.flags & 524288) { + var resolved = resolveStructuredTypeMembers(type); + var symbol = resolved.members.get(name); + if (symbol && symbolIsValue(symbol)) { + return symbol; + } + var functionType = resolved === anyFunctionType ? globalFunctionType : + resolved.callSignatures.length ? globalCallableFunctionType : + resolved.constructSignatures.length ? globalNewableFunctionType : + undefined; + if (functionType) { + var symbol_1 = getPropertyOfObjectType(functionType, name); + if (symbol_1) { + return symbol_1; + } + } + return getPropertyOfObjectType(globalObjectType, name); + } + if (type.flags & 3145728) { + return getPropertyOfUnionOrIntersectionType(type, name); + } + return undefined; + } + function getSignaturesOfStructuredType(type, kind) { + if (type.flags & 3670016) { + var resolved = resolveStructuredTypeMembers(type); + return kind === 0 ? resolved.callSignatures : resolved.constructSignatures; + } + return ts.emptyArray; + } + function getSignaturesOfType(type, kind) { + return getSignaturesOfStructuredType(getApparentType(type), kind); + } + function getIndexInfoOfStructuredType(type, kind) { + if (type.flags & 3670016) { + var resolved = resolveStructuredTypeMembers(type); + return kind === 0 ? resolved.stringIndexInfo : resolved.numberIndexInfo; + } + } + function getIndexTypeOfStructuredType(type, kind) { + var info = getIndexInfoOfStructuredType(type, kind); + return info && info.type; + } + function getIndexInfoOfType(type, kind) { + return getIndexInfoOfStructuredType(getApparentType(type), kind); + } + function getIndexTypeOfType(type, kind) { + return getIndexTypeOfStructuredType(getApparentType(type), kind); + } + function getImplicitIndexTypeOfType(type, kind) { + if (isObjectTypeWithInferableIndex(type)) { + var propTypes = []; + for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + if (kind === 0 || isNumericLiteralName(prop.escapedName)) { + propTypes.push(getTypeOfSymbol(prop)); + } + } + if (kind === 0) { + ts.append(propTypes, getIndexTypeOfType(type, 1)); + } + if (propTypes.length) { + return getUnionType(propTypes, 2); + } + } + return undefined; + } + function getTypeParametersFromDeclaration(declaration) { + var result; + for (var _i = 0, _a = ts.getEffectiveTypeParameterDeclarations(declaration); _i < _a.length; _i++) { + var node = _a[_i]; + result = ts.appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol)); + } + return result; + } + function symbolsToArray(symbols) { + var result = []; + symbols.forEach(function (symbol, id) { + if (!isReservedMemberName(id)) { + result.push(symbol); + } + }); + return result; + } + function isJSDocOptionalParameter(node) { + return ts.isInJSFile(node) && (node.type && node.type.kind === 299 + || ts.getJSDocParameterTags(node).some(function (_a) { + var isBracketed = _a.isBracketed, typeExpression = _a.typeExpression; + return isBracketed || !!typeExpression && typeExpression.type.kind === 299; + })); + } + function tryFindAmbientModule(moduleName, withAugmentations) { + if (ts.isExternalModuleNameRelative(moduleName)) { + return undefined; + } + var symbol = getSymbol(globals, '"' + moduleName + '"', 512); + return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol; + } + function isOptionalParameter(node) { + if (ts.hasQuestionToken(node) || isOptionalJSDocParameterTag(node) || isJSDocOptionalParameter(node)) { + return true; + } + if (node.initializer) { + var signature = getSignatureFromDeclaration(node.parent); + var parameterIndex = node.parent.parameters.indexOf(node); + ts.Debug.assert(parameterIndex >= 0); + return parameterIndex >= getMinArgumentCount(signature); + } + var iife = ts.getImmediatelyInvokedFunctionExpression(node.parent); + if (iife) { + return !node.type && + !node.dotDotDotToken && + node.parent.parameters.indexOf(node) >= iife.arguments.length; + } + return false; + } + function isOptionalJSDocParameterTag(node) { + if (!ts.isJSDocParameterTag(node)) { + return false; + } + var isBracketed = node.isBracketed, typeExpression = node.typeExpression; + return isBracketed || !!typeExpression && typeExpression.type.kind === 299; + } + function createTypePredicate(kind, parameterName, parameterIndex, type) { + return { kind: kind, parameterName: parameterName, parameterIndex: parameterIndex, type: type }; + } + function getMinTypeArgumentCount(typeParameters) { + var minTypeArgumentCount = 0; + if (typeParameters) { + for (var i = 0; i < typeParameters.length; i++) { + if (!hasTypeParameterDefault(typeParameters[i])) { + minTypeArgumentCount = i + 1; + } + } + } + return minTypeArgumentCount; + } + function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) { + var numTypeParameters = ts.length(typeParameters); + if (!numTypeParameters) { + return []; + } + var numTypeArguments = ts.length(typeArguments); + if (isJavaScriptImplicitAny || (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters)) { + var result = typeArguments ? typeArguments.slice() : []; + for (var i = numTypeArguments; i < numTypeParameters; i++) { + result[i] = errorType; + } + var baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny); + for (var i = numTypeArguments; i < numTypeParameters; i++) { + var defaultType = getDefaultFromTypeParameter(typeParameters[i]); + if (isJavaScriptImplicitAny && defaultType && (isTypeIdenticalTo(defaultType, unknownType) || isTypeIdenticalTo(defaultType, emptyObjectType))) { + defaultType = anyType; + } + result[i] = defaultType ? instantiateType(defaultType, createTypeMapper(typeParameters, result)) : baseDefaultType; + } + result.length = typeParameters.length; + return result; + } + return typeArguments && typeArguments.slice(); + } + function getSignatureFromDeclaration(declaration) { + var links = getNodeLinks(declaration); + if (!links.resolvedSignature) { + var parameters = []; + var flags = 0; + var minArgumentCount = 0; + var thisParameter = void 0; + var hasThisParameter = false; + var iife = ts.getImmediatelyInvokedFunctionExpression(declaration); + var isJSConstructSignature = ts.isJSDocConstructSignature(declaration); + var isUntypedSignatureInJSFile = !iife && + ts.isInJSFile(declaration) && + ts.isValueSignatureDeclaration(declaration) && + !ts.hasJSDocParameterTags(declaration) && + !ts.getJSDocType(declaration); + for (var i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) { + var param = declaration.parameters[i]; + var paramSymbol = param.symbol; + var type = ts.isJSDocParameterTag(param) ? (param.typeExpression && param.typeExpression.type) : param.type; + if (paramSymbol && !!(paramSymbol.flags & 4) && !ts.isBindingPattern(param.name)) { + var resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551, undefined, undefined, false); + paramSymbol = resolvedSymbol; + } + if (i === 0 && paramSymbol.escapedName === "this") { + hasThisParameter = true; + thisParameter = param.symbol; + } + else { + parameters.push(paramSymbol); + } + if (type && type.kind === 187) { + flags |= 2; + } + var isOptionalParameter_1 = isOptionalJSDocParameterTag(param) || + param.initializer || param.questionToken || param.dotDotDotToken || + iife && parameters.length > iife.arguments.length && !type || + isUntypedSignatureInJSFile || + isJSDocOptionalParameter(param); + if (!isOptionalParameter_1) { + minArgumentCount = parameters.length; + } + } + if ((declaration.kind === 163 || declaration.kind === 164) && + !hasNonBindableDynamicName(declaration) && + (!hasThisParameter || !thisParameter)) { + var otherKind = declaration.kind === 163 ? 164 : 163; + var other = ts.getDeclarationOfKind(getSymbolOfNode(declaration), otherKind); + if (other) { + thisParameter = getAnnotatedAccessorThisParameter(other); + } + } + var classType = declaration.kind === 162 ? + getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)) + : undefined; + var typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration); + if (ts.hasRestParameter(declaration) || ts.isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) { + flags |= 1; + } + links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, undefined, undefined, minArgumentCount, flags); + } + return links.resolvedSignature; + } + function maybeAddJsSyntheticRestParameter(declaration, parameters) { + if (ts.isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) { + return false; + } + var lastParam = ts.lastOrUndefined(declaration.parameters); + var lastParamTags = lastParam ? ts.getJSDocParameterTags(lastParam) : ts.getJSDocTags(declaration).filter(ts.isJSDocParameterTag); + var lastParamVariadicType = ts.firstDefined(lastParamTags, function (p) { + return p.typeExpression && ts.isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : undefined; + }); + var syntheticArgsSymbol = createSymbol(3, "args", 32768); + syntheticArgsSymbol.type = lastParamVariadicType ? createArrayType(getTypeFromTypeNode(lastParamVariadicType.type)) : anyArrayType; + if (lastParamVariadicType) { + parameters.pop(); + } + parameters.push(syntheticArgsSymbol); + return true; + } + function getSignatureOfTypeTag(node) { + var typeTag = ts.isInJSFile(node) ? ts.getJSDocTypeTag(node) : undefined; + var signature = typeTag && typeTag.typeExpression && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression)); + return signature && getErasedSignature(signature); + } + function getReturnTypeOfTypeTag(node) { + var signature = getSignatureOfTypeTag(node); + return signature && getReturnTypeOfSignature(signature); + } + function containsArgumentsReference(declaration) { + var links = getNodeLinks(declaration); + if (links.containsArgumentsReference === undefined) { + if (links.flags & 8192) { + links.containsArgumentsReference = true; + } + else { + links.containsArgumentsReference = traverse(declaration.body); + } + } + return links.containsArgumentsReference; + function traverse(node) { + if (!node) + return false; + switch (node.kind) { + case 75: + return node.escapedText === "arguments" && ts.isExpressionNode(node); + case 159: + case 161: + case 163: + case 164: + return node.name.kind === 154 + && traverse(node.name); + default: + return !ts.nodeStartsNewLexicalEnvironment(node) && !ts.isPartOfTypeNode(node) && !!ts.forEachChild(node, traverse); + } + } + } + function getSignaturesOfSymbol(symbol) { + if (!symbol) + return ts.emptyArray; + var result = []; + for (var i = 0; i < symbol.declarations.length; i++) { + var decl = symbol.declarations[i]; + if (!ts.isFunctionLike(decl)) + continue; + if (i > 0 && decl.body) { + var previous = symbol.declarations[i - 1]; + if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) { + continue; + } + } + result.push(getSignatureFromDeclaration(decl)); + } + return result; + } + function resolveExternalModuleTypeByLiteral(name) { + var moduleSym = resolveExternalModuleName(name, name); + if (moduleSym) { + var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym); + if (resolvedModuleSymbol) { + return getTypeOfSymbol(resolvedModuleSymbol); + } + } + return anyType; + } + function getThisTypeOfSignature(signature) { + if (signature.thisParameter) { + return getTypeOfSymbol(signature.thisParameter); + } + } + function getTypePredicateOfSignature(signature) { + if (!signature.resolvedTypePredicate) { + if (signature.target) { + var targetTypePredicate = getTypePredicateOfSignature(signature.target); + signature.resolvedTypePredicate = targetTypePredicate ? instantiateTypePredicate(targetTypePredicate, signature.mapper) : noTypePredicate; + } + else if (signature.unionSignatures) { + signature.resolvedTypePredicate = getUnionTypePredicate(signature.unionSignatures) || noTypePredicate; + } + else { + var type = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration); + var jsdocPredicate = void 0; + if (!type && ts.isInJSFile(signature.declaration)) { + var jsdocSignature = getSignatureOfTypeTag(signature.declaration); + if (jsdocSignature && signature !== jsdocSignature) { + jsdocPredicate = getTypePredicateOfSignature(jsdocSignature); + } + } + signature.resolvedTypePredicate = type && ts.isTypePredicateNode(type) ? + createTypePredicateFromTypePredicateNode(type, signature) : + jsdocPredicate || noTypePredicate; + } + ts.Debug.assert(!!signature.resolvedTypePredicate); + } + return signature.resolvedTypePredicate === noTypePredicate ? undefined : signature.resolvedTypePredicate; + } + function createTypePredicateFromTypePredicateNode(node, signature) { + var parameterName = node.parameterName; + var type = node.type && getTypeFromTypeNode(node.type); + return parameterName.kind === 183 ? + createTypePredicate(node.assertsModifier ? 2 : 0, undefined, undefined, type) : + createTypePredicate(node.assertsModifier ? 3 : 1, parameterName.escapedText, ts.findIndex(signature.parameters, function (p) { return p.escapedName === parameterName.escapedText; }), type); + } + function getReturnTypeOfSignature(signature) { + if (!signature.resolvedReturnType) { + if (!pushTypeResolution(signature, 3)) { + return errorType; + } + var type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) : + signature.unionSignatures ? getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature), 2) : + getReturnTypeFromAnnotation(signature.declaration) || + (ts.nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration)); + if (signature.flags & 4) { + type = addOptionalTypeMarker(type); + } + else if (signature.flags & 8) { + type = getOptionalType(type); + } + if (!popTypeResolution()) { + if (signature.declaration) { + var typeNode = ts.getEffectiveReturnTypeNode(signature.declaration); + if (typeNode) { + error(typeNode, ts.Diagnostics.Return_type_annotation_circularly_references_itself); + } + else if (noImplicitAny) { + var declaration = signature.declaration; + var name = ts.getNameOfDeclaration(declaration); + if (name) { + error(name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(name)); + } + else { + error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions); + } + } + } + type = anyType; + } + signature.resolvedReturnType = type; + } + return signature.resolvedReturnType; + } + function getReturnTypeFromAnnotation(declaration) { + if (declaration.kind === 162) { + return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)); + } + if (ts.isJSDocConstructSignature(declaration)) { + return getTypeFromTypeNode(declaration.parameters[0].type); + } + var typeNode = ts.getEffectiveReturnTypeNode(declaration); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + if (declaration.kind === 163 && !hasNonBindableDynamicName(declaration)) { + var jsDocType = ts.isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration); + if (jsDocType) { + return jsDocType; + } + var setter = ts.getDeclarationOfKind(getSymbolOfNode(declaration), 164); + var setterType = getAnnotatedAccessorType(setter); + if (setterType) { + return setterType; + } + } + return getReturnTypeOfTypeTag(declaration); + } + function isResolvingReturnTypeOfSignature(signature) { + return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3) >= 0; + } + function getRestTypeOfSignature(signature) { + return tryGetRestTypeOfSignature(signature) || anyType; + } + function tryGetRestTypeOfSignature(signature) { + if (signatureHasRestParameter(signature)) { + var sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + var restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType; + return restType && getIndexTypeOfType(restType, 1); + } + return undefined; + } + function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) { + var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript)); + if (inferredTypeParameters) { + var returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature)); + if (returnSignature) { + var newReturnSignature = cloneSignature(returnSignature); + newReturnSignature.typeParameters = inferredTypeParameters; + var newInstantiatedSignature = cloneSignature(instantiatedSignature); + newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature); + return newInstantiatedSignature; + } + } + return instantiatedSignature; + } + function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) { + var instantiations = signature.instantiations || (signature.instantiations = ts.createMap()); + var id = getTypeListId(typeArguments); + var instantiation = instantiations.get(id); + if (!instantiation) { + instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments)); + } + return instantiation; + } + function createSignatureInstantiation(signature, typeArguments) { + return instantiateSignature(signature, createSignatureTypeMapper(signature, typeArguments), true); + } + function createSignatureTypeMapper(signature, typeArguments) { + return createTypeMapper(signature.typeParameters, typeArguments); + } + function getErasedSignature(signature) { + return signature.typeParameters ? + signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : + signature; + } + function createErasedSignature(signature) { + return instantiateSignature(signature, createTypeEraser(signature.typeParameters), true); + } + function getCanonicalSignature(signature) { + return signature.typeParameters ? + signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) : + signature; + } + function createCanonicalSignature(signature) { + return getSignatureInstantiation(signature, ts.map(signature.typeParameters, function (tp) { return tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp; }), ts.isInJSFile(signature.declaration)); + } + function getBaseSignature(signature) { + var typeParameters = signature.typeParameters; + if (typeParameters) { + var typeEraser_1 = createTypeEraser(typeParameters); + var baseConstraints = ts.map(typeParameters, function (tp) { return instantiateType(getBaseConstraintOfType(tp), typeEraser_1) || unknownType; }); + return instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), true); + } + return signature; + } + function getOrCreateTypeFromSignature(signature) { + if (!signature.isolatedSignatureType) { + var kind = signature.declaration ? signature.declaration.kind : 0; + var isConstructor = kind === 162 || kind === 166 || kind === 171; + var type = createObjectType(16); + type.members = emptySymbols; + type.properties = ts.emptyArray; + type.callSignatures = !isConstructor ? [signature] : ts.emptyArray; + type.constructSignatures = isConstructor ? [signature] : ts.emptyArray; + signature.isolatedSignatureType = type; + } + return signature.isolatedSignatureType; + } + function getIndexSymbol(symbol) { + return symbol.members.get("__index"); + } + function getIndexDeclarationOfSymbol(symbol, kind) { + var syntaxKind = kind === 1 ? 140 : 143; + var indexSymbol = getIndexSymbol(symbol); + if (indexSymbol) { + for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var node = ts.cast(decl, ts.isIndexSignatureDeclaration); + if (node.parameters.length === 1) { + var parameter = node.parameters[0]; + if (parameter.type && parameter.type.kind === syntaxKind) { + return node; + } + } + } + } + return undefined; + } + function createIndexInfo(type, isReadonly, declaration) { + return { type: type, isReadonly: isReadonly, declaration: declaration }; + } + function getIndexInfoOfSymbol(symbol, kind) { + var declaration = getIndexDeclarationOfSymbol(symbol, kind); + if (declaration) { + return createIndexInfo(declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasModifier(declaration, 64), declaration); + } + return undefined; + } + function getConstraintDeclaration(type) { + return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0]; + } + function getInferredTypeParameterConstraint(typeParameter) { + var inferences; + if (typeParameter.symbol) { + for (var _i = 0, _a = typeParameter.symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.parent.kind === 181) { + var grandParent = declaration.parent.parent; + if (grandParent.kind === 169) { + var typeReference = grandParent; + var typeParameters = getTypeParametersForTypeReference(typeReference); + if (typeParameters) { + var index = typeReference.typeArguments.indexOf(declaration.parent); + if (index < typeParameters.length) { + var declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]); + if (declaredConstraint) { + var mapper = createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReference, typeParameters)); + var constraint = instantiateType(declaredConstraint, mapper); + if (constraint !== typeParameter) { + inferences = ts.append(inferences, constraint); + } + } + } + } + } + else if (grandParent.kind === 156 && grandParent.dotDotDotToken) { + inferences = ts.append(inferences, createArrayType(unknownType)); + } + } + } + } + return inferences && getIntersectionType(inferences); + } + function getConstraintFromTypeParameter(typeParameter) { + if (!typeParameter.constraint) { + if (typeParameter.target) { + var targetConstraint = getConstraintOfTypeParameter(typeParameter.target); + typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType; + } + else { + var constraintDeclaration = getConstraintDeclaration(typeParameter); + typeParameter.constraint = constraintDeclaration ? getTypeFromTypeNode(constraintDeclaration) : + getInferredTypeParameterConstraint(typeParameter) || noConstraintType; + } + } + return typeParameter.constraint === noConstraintType ? undefined : typeParameter.constraint; + } + function getParentSymbolOfTypeParameter(typeParameter) { + var tp = ts.getDeclarationOfKind(typeParameter.symbol, 155); + var host = ts.isJSDocTemplateTag(tp.parent) ? ts.getHostSignatureFromJSDoc(tp.parent) : tp.parent; + return host && getSymbolOfNode(host); + } + function getTypeListId(types) { + var result = ""; + if (types) { + var length_3 = types.length; + var i = 0; + while (i < length_3) { + var startId = types[i].id; + var count = 1; + while (i + count < length_3 && types[i + count].id === startId + count) { + count++; + } + if (result.length) { + result += ","; + } + result += startId; + if (count > 1) { + result += ":" + count; + } + i += count; + } + } + return result; + } + function getPropagatingFlagsOfTypes(types, excludeKinds) { + var result = 0; + for (var _i = 0, types_7 = types; _i < types_7.length; _i++) { + var type = types_7[_i]; + if (!(type.flags & excludeKinds)) { + result |= ts.getObjectFlags(type); + } + } + return result & 3670016; + } + function createTypeReference(target, typeArguments) { + var id = getTypeListId(typeArguments); + var type = target.instantiations.get(id); + if (!type) { + type = createObjectType(4, target.symbol); + target.instantiations.set(id, type); + type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, 0) : 0; + type.target = target; + type.resolvedTypeArguments = typeArguments; + } + return type; + } + function cloneTypeReference(source) { + var type = createType(source.flags); + type.symbol = source.symbol; + type.objectFlags = source.objectFlags; + type.target = source.target; + type.resolvedTypeArguments = source.resolvedTypeArguments; + return type; + } + function createDeferredTypeReference(target, node, mapper) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + var type = createObjectType(4, target.symbol); + type.target = target; + type.node = node; + type.mapper = mapper; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = mapper ? instantiateTypes(aliasTypeArguments, mapper) : aliasTypeArguments; + return type; + } + function getTypeArguments(type) { + var _a, _b; + if (!type.resolvedTypeArguments) { + if (!pushTypeResolution(type, 6)) { + return ((_a = type.target.localTypeParameters) === null || _a === void 0 ? void 0 : _a.map(function () { return errorType; })) || ts.emptyArray; + } + var node = type.node; + var typeArguments = !node ? ts.emptyArray : + node.kind === 169 ? ts.concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) : + node.kind === 174 ? [getTypeFromTypeNode(node.elementType)] : + ts.map(node.elementTypes, getTypeFromTypeNode); + if (popTypeResolution()) { + type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; + } + else { + type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) === null || _b === void 0 ? void 0 : _b.map(function () { return errorType; })) || ts.emptyArray; + error(type.node || currentNode, type.target.symbol + ? ts.Diagnostics.Type_arguments_for_0_circularly_reference_themselves + : ts.Diagnostics.Tuple_type_arguments_circularly_reference_themselves, type.target.symbol && symbolToString(type.target.symbol)); + } + } + return type.resolvedTypeArguments; + } + function getTypeReferenceArity(type) { + return ts.length(type.target.typeParameters); + } + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol)); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + var numTypeArguments = ts.length(node.typeArguments); + var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters); + var isJs = ts.isInJSFile(node); + var isJsImplicitAny = !noImplicitAny && isJs; + if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) { + var missingAugmentsTag = isJs && ts.isExpressionWithTypeArguments(node) && !ts.isJSDocAugmentsTag(node.parent); + var diag = minTypeArgumentCount === typeParameters.length ? + missingAugmentsTag ? + ts.Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag : + ts.Diagnostics.Generic_type_0_requires_1_type_argument_s : + missingAugmentsTag ? + ts.Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag : + ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments; + var typeStr = typeToString(type, undefined, 2); + error(node, diag, typeStr, minTypeArgumentCount, typeParameters.length); + if (!isJs) { + return errorType; + } + } + if (node.kind === 169 && isAliasedType(node)) { + return createDeferredTypeReference(type, node, undefined); + } + var typeArguments = ts.concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs)); + return createTypeReference(type, typeArguments); + } + return checkNoTypeArguments(node, symbol) ? type : errorType; + } + function getTypeAliasInstantiation(symbol, typeArguments) { + var type = getDeclaredTypeOfSymbol(symbol); + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + var id = getTypeListId(typeArguments); + var instantiation = links.instantiations.get(id); + if (!instantiation) { + links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration))))); + } + return instantiation; + } + function getTypeFromTypeAliasReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = getSymbolLinks(symbol).typeParameters; + if (typeParameters) { + var numTypeArguments = ts.length(node.typeArguments); + var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters); + if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) { + error(node, minTypeArgumentCount === typeParameters.length ? + ts.Diagnostics.Generic_type_0_requires_1_type_argument_s : + ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length); + return errorType; + } + return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node)); + } + return checkNoTypeArguments(node, symbol) ? type : errorType; + } + function getTypeReferenceName(node) { + switch (node.kind) { + case 169: + return node.typeName; + case 216: + var expr = node.expression; + if (ts.isEntityNameExpression(expr)) { + return expr; + } + } + return undefined; + } + function resolveTypeReferenceName(typeReferenceName, meaning, ignoreErrors) { + if (!typeReferenceName) { + return unknownSymbol; + } + return resolveEntityName(typeReferenceName, meaning, ignoreErrors) || unknownSymbol; + } + function getTypeReferenceType(node, symbol) { + if (symbol === unknownSymbol) { + return errorType; + } + symbol = getExpandoSymbol(symbol) || symbol; + if (symbol.flags & (32 | 64)) { + return getTypeFromClassOrInterfaceReference(node, symbol); + } + if (symbol.flags & 524288) { + return getTypeFromTypeAliasReference(node, symbol); + } + var res = tryGetDeclaredTypeOfSymbol(symbol); + if (res) { + return checkNoTypeArguments(node, symbol) ? + res.flags & 262144 ? getConstrainedTypeVariable(res, node) : getRegularTypeOfLiteralType(res) : + errorType; + } + if (symbol.flags & 111551 && isJSDocTypeReference(node)) { + var jsdocType = getTypeFromJSDocValueReference(node, symbol); + if (jsdocType) { + return jsdocType; + } + else { + resolveTypeReferenceName(getTypeReferenceName(node), 788968); + return getTypeOfSymbol(symbol); + } + } + return errorType; + } + function getTypeFromJSDocValueReference(node, symbol) { + var links = getNodeLinks(node); + if (!links.resolvedJSDocType) { + var valueType = getTypeOfSymbol(symbol); + var typeType = valueType; + if (symbol.valueDeclaration) { + var decl = ts.getRootDeclaration(symbol.valueDeclaration); + var isRequireAlias = false; + if (ts.isVariableDeclaration(decl) && decl.initializer) { + var expr = decl.initializer; + while (ts.isPropertyAccessExpression(expr)) { + expr = expr.expression; + } + isRequireAlias = ts.isCallExpression(expr) && ts.isRequireCall(expr, true) && !!valueType.symbol; + } + var isImportTypeWithQualifier = node.kind === 188 && node.qualifier; + if (valueType.symbol && (isRequireAlias || isImportTypeWithQualifier)) { + typeType = getTypeReferenceType(node, valueType.symbol); + } + } + links.resolvedJSDocType = typeType; + } + return links.resolvedJSDocType; + } + function getSubstitutionType(typeVariable, substitute) { + if (substitute.flags & 3 || substitute === typeVariable) { + return typeVariable; + } + var id = getTypeId(typeVariable) + ">" + getTypeId(substitute); + var cached = substitutionTypes.get(id); + if (cached) { + return cached; + } + var result = createType(33554432); + result.typeVariable = typeVariable; + result.substitute = substitute; + substitutionTypes.set(id, result); + return result; + } + function isUnaryTupleTypeNode(node) { + return node.kind === 175 && node.elementTypes.length === 1; + } + function getImpliedConstraint(typeVariable, checkNode, extendsNode) { + return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(typeVariable, checkNode.elementTypes[0], extendsNode.elementTypes[0]) : + getActualTypeVariable(getTypeFromTypeNode(checkNode)) === typeVariable ? getTypeFromTypeNode(extendsNode) : + undefined; + } + function getConstrainedTypeVariable(typeVariable, node) { + var constraints; + while (node && !ts.isStatement(node) && node.kind !== 303) { + var parent = node.parent; + if (parent.kind === 180 && node === parent.trueType) { + var constraint = getImpliedConstraint(typeVariable, parent.checkType, parent.extendsType); + if (constraint) { + constraints = ts.append(constraints, constraint); + } + } + node = parent; + } + return constraints ? getSubstitutionType(typeVariable, getIntersectionType(ts.append(constraints, typeVariable))) : typeVariable; + } + function isJSDocTypeReference(node) { + return !!(node.flags & 4194304) && (node.kind === 169 || node.kind === 188); + } + function checkNoTypeArguments(node, symbol) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? ts.declarationNameToString(node.typeName) : anon); + return false; + } + return true; + } + function getIntendedTypeFromJSDocTypeReference(node) { + if (ts.isIdentifier(node.typeName)) { + var typeArgs = node.typeArguments; + switch (node.typeName.escapedText) { + case "String": + checkNoTypeArguments(node); + return stringType; + case "Number": + checkNoTypeArguments(node); + return numberType; + case "Boolean": + checkNoTypeArguments(node); + return booleanType; + case "Void": + checkNoTypeArguments(node); + return voidType; + case "Undefined": + checkNoTypeArguments(node); + return undefinedType; + case "Null": + checkNoTypeArguments(node); + return nullType; + case "Function": + case "function": + checkNoTypeArguments(node); + return globalFunctionType; + case "array": + return (!typeArgs || !typeArgs.length) && !noImplicitAny ? anyArrayType : undefined; + case "promise": + return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : undefined; + case "Object": + if (typeArgs && typeArgs.length === 2) { + if (ts.isJSDocIndexSignature(node)) { + var indexed = getTypeFromTypeNode(typeArgs[0]); + var target = getTypeFromTypeNode(typeArgs[1]); + var index = createIndexInfo(target, false); + return createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, indexed === stringType ? index : undefined, indexed === numberType ? index : undefined); + } + return anyType; + } + checkNoTypeArguments(node); + return !noImplicitAny ? anyType : undefined; + } + } + } + function getTypeFromJSDocNullableTypeNode(node) { + var type = getTypeFromTypeNode(node.type); + return strictNullChecks ? getNullableType(type, 65536) : type; + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var symbol = void 0; + var type = void 0; + var meaning = 788968; + if (isJSDocTypeReference(node)) { + type = getIntendedTypeFromJSDocTypeReference(node); + if (!type) { + symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning, true); + if (symbol === unknownSymbol) { + symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning | 111551); + } + else { + resolveTypeReferenceName(getTypeReferenceName(node), meaning); + } + type = getTypeReferenceType(node, symbol); + } + } + if (!type) { + symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning); + type = getTypeReferenceType(node, symbol); + } + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } + function typeArgumentsFromTypeReferenceNode(node) { + return ts.map(node.typeArguments, getTypeFromTypeNode); + } + function getTypeFromTypeQueryNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(checkExpression(node.exprName))); + } + return links.resolvedType; + } + function getTypeOfGlobalSymbol(symbol, arity) { + function getTypeDeclaration(symbol) { + var declarations = symbol.declarations; + for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) { + var declaration = declarations_3[_i]; + switch (declaration.kind) { + case 245: + case 246: + case 248: + return declaration; + } + } + } + if (!symbol) { + return arity ? emptyGenericType : emptyObjectType; + } + var type = getDeclaredTypeOfSymbol(symbol); + if (!(type.flags & 524288)) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, ts.symbolName(symbol)); + return arity ? emptyGenericType : emptyObjectType; + } + if (ts.length(type.typeParameters) !== arity) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, ts.symbolName(symbol), arity); + return arity ? emptyGenericType : emptyObjectType; + } + return type; + } + function getGlobalValueSymbol(name, reportErrors) { + return getGlobalSymbol(name, 111551, reportErrors ? ts.Diagnostics.Cannot_find_global_value_0 : undefined); + } + function getGlobalTypeSymbol(name, reportErrors) { + return getGlobalSymbol(name, 788968, reportErrors ? ts.Diagnostics.Cannot_find_global_type_0 : undefined); + } + function getGlobalSymbol(name, meaning, diagnostic) { + return resolveName(undefined, name, meaning, diagnostic, name, false); + } + function getGlobalType(name, arity, reportErrors) { + var symbol = getGlobalTypeSymbol(name, reportErrors); + return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined; + } + function getGlobalTypedPropertyDescriptorType() { + return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType("TypedPropertyDescriptor", 1, true)) || emptyGenericType; + } + function getGlobalTemplateStringsArrayType() { + return deferredGlobalTemplateStringsArrayType || (deferredGlobalTemplateStringsArrayType = getGlobalType("TemplateStringsArray", 0, true)) || emptyObjectType; + } + function getGlobalImportMetaType() { + return deferredGlobalImportMetaType || (deferredGlobalImportMetaType = getGlobalType("ImportMeta", 0, true)) || emptyObjectType; + } + function getGlobalESSymbolConstructorSymbol(reportErrors) { + return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors)); + } + function getGlobalESSymbolType(reportErrors) { + return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", 0, reportErrors)) || emptyObjectType; + } + function getGlobalPromiseType(reportErrors) { + return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", 1, reportErrors)) || emptyGenericType; + } + function getGlobalPromiseLikeType(reportErrors) { + return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", 1, reportErrors)) || emptyGenericType; + } + function getGlobalPromiseConstructorSymbol(reportErrors) { + return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors)); + } + function getGlobalPromiseConstructorLikeType(reportErrors) { + return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", 0, reportErrors)) || emptyObjectType; + } + function getGlobalAsyncIterableType(reportErrors) { + return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", 1, reportErrors)) || emptyGenericType; + } + function getGlobalAsyncIteratorType(reportErrors) { + return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", 3, reportErrors)) || emptyGenericType; + } + function getGlobalAsyncIterableIteratorType(reportErrors) { + return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", 1, reportErrors)) || emptyGenericType; + } + function getGlobalAsyncGeneratorType(reportErrors) { + return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", 3, reportErrors)) || emptyGenericType; + } + function getGlobalIterableType(reportErrors) { + return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", 1, reportErrors)) || emptyGenericType; + } + function getGlobalIteratorType(reportErrors) { + return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", 3, reportErrors)) || emptyGenericType; + } + function getGlobalIterableIteratorType(reportErrors) { + return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", 1, reportErrors)) || emptyGenericType; + } + function getGlobalGeneratorType(reportErrors) { + return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", 3, reportErrors)) || emptyGenericType; + } + function getGlobalIteratorYieldResultType(reportErrors) { + return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", 1, reportErrors)) || emptyGenericType; + } + function getGlobalIteratorReturnResultType(reportErrors) { + return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", 1, reportErrors)) || emptyGenericType; + } + function getGlobalTypeOrUndefined(name, arity) { + if (arity === void 0) { arity = 0; } + var symbol = getGlobalSymbol(name, 788968, undefined); + return symbol && getTypeOfGlobalSymbol(symbol, arity); + } + function getGlobalExtractSymbol() { + return deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalSymbol("Extract", 524288, ts.Diagnostics.Cannot_find_global_type_0)); + } + function getGlobalOmitSymbol() { + return deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalSymbol("Omit", 524288, ts.Diagnostics.Cannot_find_global_type_0)); + } + function getGlobalBigIntType(reportErrors) { + return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", 0, reportErrors)) || emptyObjectType; + } + function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) { + return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType; + } + function createTypedPropertyDescriptorType(propertyType) { + return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]); + } + function createIterableType(iteratedType) { + return createTypeFromGenericGlobalType(getGlobalIterableType(true), [iteratedType]); + } + function createArrayType(elementType, readonly) { + return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]); + } + function getArrayOrTupleTargetType(node) { + var readonly = isReadonlyTypeOperator(node.parent); + if (node.kind === 174 || node.elementTypes.length === 1 && node.elementTypes[0].kind === 177) { + return readonly ? globalReadonlyArrayType : globalArrayType; + } + var lastElement = ts.lastOrUndefined(node.elementTypes); + var restElement = lastElement && lastElement.kind === 177 ? lastElement : undefined; + var minLength = ts.findLastIndex(node.elementTypes, function (n) { return n.kind !== 176 && n !== restElement; }) + 1; + return getTupleTypeOfArity(node.elementTypes.length, minLength, !!restElement, readonly, undefined); + } + function isAliasedType(node) { + var parent = node.parent; + switch (parent.kind) { + case 182: + case 169: + case 178: + case 179: + case 185: + case 180: + case 184: + return isAliasedType(parent); + case 247: + return true; + } + return false; + } + function getTypeFromArrayOrTupleTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var target = getArrayOrTupleTargetType(node); + if (target === emptyGenericType) { + links.resolvedType = emptyObjectType; + } + else if (isAliasedType(node)) { + links.resolvedType = node.kind === 175 && node.elementTypes.length === 0 ? target : + createDeferredTypeReference(target, node, undefined); + } + else { + var elementTypes = node.kind === 174 ? [getTypeFromTypeNode(node.elementType)] : ts.map(node.elementTypes, getTypeFromTypeNode); + links.resolvedType = createTypeReference(target, elementTypes); + } + } + return links.resolvedType; + } + function isReadonlyTypeOperator(node) { + return ts.isTypeOperatorNode(node) && node.operator === 138; + } + function createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames) { + var typeParameters; + var properties = []; + var maxLength = hasRestElement ? arity - 1 : arity; + if (arity) { + typeParameters = new Array(arity); + for (var i = 0; i < arity; i++) { + var typeParameter = typeParameters[i] = createTypeParameter(); + if (i < maxLength) { + var property = createSymbol(4 | (i >= minLength ? 16777216 : 0), "" + i, readonly ? 8 : 0); + property.type = typeParameter; + properties.push(property); + } + } + } + var literalTypes = []; + for (var i = minLength; i <= maxLength; i++) + literalTypes.push(getLiteralType(i)); + var lengthSymbol = createSymbol(4, "length"); + lengthSymbol.type = hasRestElement ? numberType : getUnionType(literalTypes); + properties.push(lengthSymbol); + var type = createObjectType(8 | 4); + type.typeParameters = typeParameters; + type.outerTypeParameters = undefined; + type.localTypeParameters = typeParameters; + type.instantiations = ts.createMap(); + type.instantiations.set(getTypeListId(type.typeParameters), type); + type.target = type; + type.resolvedTypeArguments = type.typeParameters; + type.thisType = createTypeParameter(); + type.thisType.isThisType = true; + type.thisType.constraint = type; + type.declaredProperties = properties; + type.declaredCallSignatures = ts.emptyArray; + type.declaredConstructSignatures = ts.emptyArray; + type.declaredStringIndexInfo = undefined; + type.declaredNumberIndexInfo = undefined; + type.minLength = minLength; + type.hasRestElement = hasRestElement; + type.readonly = readonly; + type.associatedNames = associatedNames; + return type; + } + function getTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames) { + var key = arity + (hasRestElement ? "+" : ",") + minLength + (readonly ? "R" : "") + (associatedNames && associatedNames.length ? "," + associatedNames.join(",") : ""); + var type = tupleTypes.get(key); + if (!type) { + tupleTypes.set(key, type = createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames)); + } + return type; + } + function createTupleType(elementTypes, minLength, hasRestElement, readonly, associatedNames) { + if (minLength === void 0) { minLength = elementTypes.length; } + if (hasRestElement === void 0) { hasRestElement = false; } + if (readonly === void 0) { readonly = false; } + var arity = elementTypes.length; + if (arity === 1 && hasRestElement) { + return createArrayType(elementTypes[0], readonly); + } + var tupleType = getTupleTypeOfArity(arity, minLength, arity > 0 && hasRestElement, readonly, associatedNames); + return elementTypes.length ? createTypeReference(tupleType, elementTypes) : tupleType; + } + function sliceTupleType(type, index) { + var tuple = type.target; + if (tuple.hasRestElement) { + index = Math.min(index, getTypeReferenceArity(type) - 1); + } + return createTupleType(getTypeArguments(type).slice(index), Math.max(0, tuple.minLength - index), tuple.hasRestElement, tuple.readonly, tuple.associatedNames && tuple.associatedNames.slice(index)); + } + function getTypeFromOptionalTypeNode(node) { + var type = getTypeFromTypeNode(node.type); + return strictNullChecks ? getOptionalType(type) : type; + } + function getTypeId(type) { + return type.id; + } + function containsType(types, type) { + return ts.binarySearch(types, type, getTypeId, ts.compareValues) >= 0; + } + function insertType(types, type) { + var index = ts.binarySearch(types, type, getTypeId, ts.compareValues); + if (index < 0) { + types.splice(~index, 0, type); + return true; + } + return false; + } + function addTypeToUnion(typeSet, includes, type) { + var flags = type.flags; + if (flags & 1048576) { + return addTypesToUnion(typeSet, includes, type.types); + } + if (!(flags & 131072)) { + includes |= flags & 68943871; + if (flags & 66846720) + includes |= 262144; + if (type === wildcardType) + includes |= 4194304; + if (!strictNullChecks && flags & 98304) { + if (!(ts.getObjectFlags(type) & 524288)) + includes |= 2097152; + } + else { + var len = typeSet.length; + var index = len && type.id > typeSet[len - 1].id ? ~len : ts.binarySearch(typeSet, type, getTypeId, ts.compareValues); + if (index < 0) { + typeSet.splice(~index, 0, type); + } + } + } + return includes; + } + function addTypesToUnion(typeSet, includes, types) { + for (var _i = 0, types_8 = types; _i < types_8.length; _i++) { + var type = types_8[_i]; + includes = addTypeToUnion(typeSet, includes, type); + } + return includes; + } + function isSetOfLiteralsFromSameEnum(types) { + var first = types[0]; + if (first.flags & 1024) { + var firstEnum = getParentOfSymbol(first.symbol); + for (var i = 1; i < types.length; i++) { + var other = types[i]; + if (!(other.flags & 1024) || (firstEnum !== getParentOfSymbol(other.symbol))) { + return false; + } + } + return true; + } + return false; + } + function removeSubtypes(types, primitivesOnly) { + var len = types.length; + if (len === 0 || isSetOfLiteralsFromSameEnum(types)) { + return true; + } + var i = len; + var count = 0; + while (i > 0) { + i--; + var source = types[i]; + for (var _i = 0, types_9 = types; _i < types_9.length; _i++) { + var target = types_9[_i]; + if (source !== target) { + if (count === 100000) { + var estimatedCount = (count / (len - i)) * len; + if (estimatedCount > (primitivesOnly ? 25000000 : 1000000)) { + error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return false; + } + } + count++; + if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1) || + !(ts.getObjectFlags(getTargetType(target)) & 1) || + isTypeDerivedFrom(source, target))) { + ts.orderedRemoveItemAt(types, i); + break; + } + } + } + } + return true; + } + function removeRedundantLiteralTypes(types, includes) { + var i = types.length; + while (i > 0) { + i--; + var t = types[i]; + var remove = t.flags & 128 && includes & 4 || + t.flags & 256 && includes & 8 || + t.flags & 2048 && includes & 64 || + t.flags & 8192 && includes & 4096 || + isFreshLiteralType(t) && containsType(types, t.regularType); + if (remove) { + ts.orderedRemoveItemAt(types, i); + } + } + } + function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments) { + if (unionReduction === void 0) { unionReduction = 1; } + if (types.length === 0) { + return neverType; + } + if (types.length === 1) { + return types[0]; + } + var typeSet = []; + var includes = addTypesToUnion(typeSet, 0, types); + if (unionReduction !== 0) { + if (includes & 3) { + return includes & 1 ? includes & 4194304 ? wildcardType : anyType : unknownType; + } + switch (unionReduction) { + case 1: + if (includes & (2944 | 8192)) { + removeRedundantLiteralTypes(typeSet, includes); + } + break; + case 2: + if (!removeSubtypes(typeSet, !(includes & 262144))) { + return errorType; + } + break; + } + if (typeSet.length === 0) { + return includes & 65536 ? includes & 2097152 ? nullType : nullWideningType : + includes & 32768 ? includes & 2097152 ? undefinedType : undefinedWideningType : + neverType; + } + } + return getUnionTypeFromSortedList(typeSet, includes & 66994211 ? 0 : 262144, aliasSymbol, aliasTypeArguments); + } + function getUnionTypePredicate(signatures) { + var first; + var types = []; + for (var _i = 0, signatures_6 = signatures; _i < signatures_6.length; _i++) { + var sig = signatures_6[_i]; + var pred = getTypePredicateOfSignature(sig); + if (!pred || pred.kind === 2 || pred.kind === 3) { + continue; + } + if (first) { + if (!typePredicateKindsMatch(first, pred)) { + return undefined; + } + } + else { + first = pred; + } + types.push(pred.type); + } + if (!first) { + return undefined; + } + var unionType = getUnionType(types); + return createTypePredicate(first.kind, first.parameterName, first.parameterIndex, unionType); + } + function typePredicateKindsMatch(a, b) { + return a.kind === b.kind && a.parameterIndex === b.parameterIndex; + } + function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments) { + if (types.length === 0) { + return neverType; + } + if (types.length === 1) { + return types[0]; + } + var id = getTypeListId(types); + var type = unionTypes.get(id); + if (!type) { + type = createType(1048576); + unionTypes.set(id, type); + type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, 98304); + type.types = types; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = aliasTypeArguments; + } + return type; + } + function getTypeFromUnionTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol)); + } + return links.resolvedType; + } + function addTypeToIntersection(typeSet, includes, type) { + var flags = type.flags; + if (flags & 2097152) { + return addTypesToIntersection(typeSet, includes, type.types); + } + if (isEmptyAnonymousObjectType(type)) { + if (!(includes & 8388608)) { + includes |= 8388608; + typeSet.set(type.id.toString(), type); + } + } + else { + if (flags & 3) { + if (type === wildcardType) + includes |= 4194304; + } + else if ((strictNullChecks || !(flags & 98304)) && !typeSet.has(type.id.toString())) { + if (type.flags & 109440 && includes & 109440) { + includes |= 67108864; + } + typeSet.set(type.id.toString(), type); + } + includes |= flags & 68943871; + } + return includes; + } + function addTypesToIntersection(typeSet, includes, types) { + for (var _i = 0, types_10 = types; _i < types_10.length; _i++) { + var type = types_10[_i]; + includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type)); + } + return includes; + } + function removeRedundantPrimitiveTypes(types, includes) { + var i = types.length; + while (i > 0) { + i--; + var t = types[i]; + var remove = t.flags & 4 && includes & 128 || + t.flags & 8 && includes & 256 || + t.flags & 64 && includes & 2048 || + t.flags & 4096 && includes & 8192; + if (remove) { + ts.orderedRemoveItemAt(types, i); + } + } + } + function eachUnionContains(unionTypes, type) { + for (var _i = 0, unionTypes_1 = unionTypes; _i < unionTypes_1.length; _i++) { + var u = unionTypes_1[_i]; + if (!containsType(u.types, type)) { + var primitive = type.flags & 128 ? stringType : + type.flags & 256 ? numberType : + type.flags & 2048 ? bigintType : + type.flags & 8192 ? esSymbolType : + undefined; + if (!primitive || !containsType(u.types, primitive)) { + return false; + } + } + } + return true; + } + function extractIrreducible(types, flag) { + if (ts.every(types, function (t) { return !!(t.flags & 1048576) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); })) { + for (var i = 0; i < types.length; i++) { + types[i] = filterType(types[i], function (t) { return !(t.flags & flag); }); + } + return true; + } + return false; + } + function intersectUnionsOfPrimitiveTypes(types) { + var unionTypes; + var index = ts.findIndex(types, function (t) { return !!(ts.getObjectFlags(t) & 262144); }); + if (index < 0) { + return false; + } + var i = index + 1; + while (i < types.length) { + var t = types[i]; + if (ts.getObjectFlags(t) & 262144) { + (unionTypes || (unionTypes = [types[index]])).push(t); + ts.orderedRemoveItemAt(types, i); + } + else { + i++; + } + } + if (!unionTypes) { + return false; + } + var checked = []; + var result = []; + for (var _i = 0, unionTypes_2 = unionTypes; _i < unionTypes_2.length; _i++) { + var u = unionTypes_2[_i]; + for (var _a = 0, _b = u.types; _a < _b.length; _a++) { + var t = _b[_a]; + if (insertType(checked, t)) { + if (eachUnionContains(unionTypes, t)) { + insertType(result, t); + } + } + } + } + types[index] = getUnionTypeFromSortedList(result, 262144); + return true; + } + function createIntersectionType(types, aliasSymbol, aliasTypeArguments) { + var result = createType(2097152); + result.objectFlags = getPropagatingFlagsOfTypes(types, 98304); + result.types = types; + result.aliasSymbol = aliasSymbol; + result.aliasTypeArguments = aliasTypeArguments; + return result; + } + function getIntersectionType(types, aliasSymbol, aliasTypeArguments) { + var typeMembershipMap = ts.createMap(); + var includes = addTypesToIntersection(typeMembershipMap, 0, types); + var typeSet = ts.arrayFrom(typeMembershipMap.values()); + if (includes & 131072 || + strictNullChecks && includes & 98304 && includes & (524288 | 67108864 | 8388608) || + includes & 67108864 && includes & (67238908 & ~67108864) || + includes & 132 && includes & (67238908 & ~132) || + includes & 296 && includes & (67238908 & ~296) || + includes & 2112 && includes & (67238908 & ~2112) || + includes & 12288 && includes & (67238908 & ~12288) || + includes & 49152 && includes & (67238908 & ~49152)) { + return neverType; + } + if (includes & 1) { + return includes & 4194304 ? wildcardType : anyType; + } + if (!strictNullChecks && includes & 98304) { + return includes & 32768 ? undefinedType : nullType; + } + if (includes & 4 && includes & 128 || + includes & 8 && includes & 256 || + includes & 64 && includes & 2048 || + includes & 4096 && includes & 8192) { + removeRedundantPrimitiveTypes(typeSet, includes); + } + if (includes & 8388608 && includes & 524288) { + ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType)); + } + if (typeSet.length === 0) { + return unknownType; + } + if (typeSet.length === 1) { + return typeSet[0]; + } + var id = getTypeListId(typeSet); + var result = intersectionTypes.get(id); + if (!result) { + if (includes & 1048576) { + if (intersectUnionsOfPrimitiveTypes(typeSet)) { + result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments); + } + else if (extractIrreducible(typeSet, 32768)) { + result = getUnionType([getIntersectionType(typeSet), undefinedType], 1, aliasSymbol, aliasTypeArguments); + } + else if (extractIrreducible(typeSet, 65536)) { + result = getUnionType([getIntersectionType(typeSet), nullType], 1, aliasSymbol, aliasTypeArguments); + } + else { + var size = ts.reduceLeft(typeSet, function (n, t) { return n * (t.flags & 1048576 ? t.types.length : 1); }, 1); + if (size >= 100000) { + error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return errorType; + } + var unionIndex_1 = ts.findIndex(typeSet, function (t) { return (t.flags & 1048576) !== 0; }); + var unionType = typeSet[unionIndex_1]; + result = getUnionType(ts.map(unionType.types, function (t) { return getIntersectionType(ts.replaceElement(typeSet, unionIndex_1, t)); }), 1, aliasSymbol, aliasTypeArguments); + } + } + else { + result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments); + } + intersectionTypes.set(id, result); + } + return result; + } + function getTypeFromIntersectionTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol)); + } + return links.resolvedType; + } + function createIndexType(type, stringsOnly) { + var result = createType(4194304); + result.type = type; + result.stringsOnly = stringsOnly; + return result; + } + function getIndexTypeForGenericType(type, stringsOnly) { + return stringsOnly ? + type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, true)) : + type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, false)); + } + function getLiteralTypeFromPropertyName(name) { + if (ts.isPrivateIdentifier(name)) { + return neverType; + } + return ts.isIdentifier(name) ? getLiteralType(ts.unescapeLeadingUnderscores(name.escapedText)) : + getRegularTypeOfLiteralType(ts.isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name)); + } + function getBigIntLiteralType(node) { + return getLiteralType({ + negative: false, + base10Value: ts.parsePseudoBigInt(node.text) + }); + } + function getLiteralTypeFromProperty(prop, include) { + if (!(ts.getDeclarationModifierFlagsFromSymbol(prop) & 24)) { + var type = getSymbolLinks(getLateBoundSymbol(prop)).nameType; + if (!type && !ts.isKnownSymbol(prop)) { + if (prop.escapedName === "default") { + type = getLiteralType("default"); + } + else { + var name = prop.valueDeclaration && ts.getNameOfDeclaration(prop.valueDeclaration); + type = name && getLiteralTypeFromPropertyName(name) || getLiteralType(ts.symbolName(prop)); + } + } + if (type && type.flags & include) { + return type; + } + } + return neverType; + } + function getLiteralTypeFromProperties(type, include) { + return getUnionType(ts.map(getPropertiesOfType(type), function (p) { return getLiteralTypeFromProperty(p, include); })); + } + function getNonEnumNumberIndexInfo(type) { + var numberIndexInfo = getIndexInfoOfType(type, 1); + return numberIndexInfo !== enumNumberIndexInfo ? numberIndexInfo : undefined; + } + function getIndexType(type, stringsOnly, noIndexSignatures) { + if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; } + return type.flags & 1048576 ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : + type.flags & 2097152 ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : + maybeTypeOfKind(type, 58982400) ? getIndexTypeForGenericType(type, stringsOnly) : + ts.getObjectFlags(type) & 32 ? filterType(getConstraintTypeFromMappedType(type), function (t) { return !(noIndexSignatures && t.flags & (1 | 4)); }) : + type === wildcardType ? wildcardType : + type.flags & 2 ? neverType : + type.flags & (1 | 131072) ? keyofConstraintType : + stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, 0) ? stringType : getLiteralTypeFromProperties(type, 128) : + !noIndexSignatures && getIndexInfoOfType(type, 0) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, 8192)]) : + getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, 128 | 8192)]) : + getLiteralTypeFromProperties(type, 8576); + } + function getExtractStringType(type) { + if (keyofStringsOnly) { + return type; + } + var extractTypeAlias = getGlobalExtractSymbol(); + return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType; + } + function getIndexTypeOrString(type) { + var indexType = getExtractStringType(getIndexType(type)); + return indexType.flags & 131072 ? stringType : indexType; + } + function getTypeFromTypeOperatorNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + switch (node.operator) { + case 134: + links.resolvedType = getIndexType(getTypeFromTypeNode(node.type)); + break; + case 147: + links.resolvedType = node.type.kind === 144 + ? getESSymbolLikeTypeForNode(ts.walkUpParenthesizedTypes(node.parent)) + : errorType; + break; + case 138: + links.resolvedType = getTypeFromTypeNode(node.type); + break; + default: + throw ts.Debug.assertNever(node.operator); + } + } + return links.resolvedType; + } + function createIndexedAccessType(objectType, indexType) { + var type = createType(8388608); + type.objectType = objectType; + type.indexType = indexType; + return type; + } + function isJSLiteralType(type) { + if (noImplicitAny) { + return false; + } + if (ts.getObjectFlags(type) & 16384) { + return true; + } + if (type.flags & 1048576) { + return ts.every(type.types, isJSLiteralType); + } + if (type.flags & 2097152) { + return ts.some(type.types, isJSLiteralType); + } + if (type.flags & 63176704) { + return isJSLiteralType(getResolvedBaseConstraint(type)); + } + return false; + } + function getPropertyNameFromIndex(indexType, accessNode) { + var accessExpression = accessNode && accessNode.kind === 195 ? accessNode : undefined; + return isTypeUsableAsPropertyName(indexType) ? + getPropertyNameFromType(indexType) : + accessExpression && checkThatExpressionIsProperSymbolReference(accessExpression.argumentExpression, indexType, false) ? + ts.getPropertyNameForKnownSymbolName(ts.idText(accessExpression.argumentExpression.name)) : + accessNode && ts.isPropertyName(accessNode) ? + ts.getPropertyNameForPropertyNameNode(accessNode) : + undefined; + } + function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, suppressNoImplicitAnyError, accessNode, accessFlags) { + var accessExpression = accessNode && accessNode.kind === 195 ? accessNode : undefined; + var propName = accessNode && ts.isPrivateIdentifier(accessNode) ? undefined : getPropertyNameFromIndex(indexType, accessNode); + if (propName !== undefined) { + var prop = getPropertyOfType(objectType, propName); + if (prop) { + if (accessExpression) { + markPropertyAsReferenced(prop, accessExpression, accessExpression.expression.kind === 104); + if (isAssignmentToReadonlyEntity(accessExpression, prop, ts.getAssignmentTargetKind(accessExpression))) { + error(accessExpression.argumentExpression, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop)); + return undefined; + } + if (accessFlags & 4) { + getNodeLinks(accessNode).resolvedSymbol = prop; + } + } + var propType = getTypeOfSymbol(prop); + return accessExpression && ts.getAssignmentTargetKind(accessExpression) !== 1 ? + getFlowTypeOfReference(accessExpression, propType) : + propType; + } + if (everyType(objectType, isTupleType) && isNumericLiteralName(propName) && +propName >= 0) { + if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 8)) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + if (isTupleType(objectType)) { + error(indexNode, ts.Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2, typeToString(objectType), getTypeReferenceArity(objectType), ts.unescapeLeadingUnderscores(propName)); + } + else { + error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType)); + } + } + errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, 1)); + return mapType(objectType, function (t) { return getRestTypeOfTupleType(t) || undefinedType; }); + } + } + if (!(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 132 | 296 | 12288)) { + if (objectType.flags & (1 | 131072)) { + return objectType; + } + var stringIndexInfo = getIndexInfoOfType(objectType, 0); + var indexInfo = isTypeAssignableToKind(indexType, 296) && getIndexInfoOfType(objectType, 1) || stringIndexInfo; + if (indexInfo) { + if (accessFlags & 1 && indexInfo === stringIndexInfo) { + if (accessExpression) { + error(accessExpression, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType)); + } + return undefined; + } + if (accessNode && !isTypeAssignableToKind(indexType, 4 | 8)) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType)); + return indexInfo.type; + } + errorIfWritingToReadonlyIndex(indexInfo); + return indexInfo.type; + } + if (indexType.flags & 131072) { + return neverType; + } + if (isJSLiteralType(objectType)) { + return anyType; + } + if (accessExpression && !isConstEnumObjectType(objectType)) { + if (objectType.symbol === globalThisSymbol && propName !== undefined && globalThisSymbol.exports.has(propName) && (globalThisSymbol.exports.get(propName).flags & 418)) { + error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType)); + } + else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !suppressNoImplicitAnyError) { + if (propName !== undefined && typeHasStaticProperty(propName, objectType)) { + error(accessExpression, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, propName, typeToString(objectType)); + } + else if (getIndexTypeOfType(objectType, 1)) { + error(accessExpression.argumentExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number); + } + else { + var suggestion = void 0; + if (propName !== undefined && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) { + if (suggestion !== undefined) { + error(accessExpression.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion); + } + } + else { + var suggestion_1 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType); + if (suggestion_1 !== undefined) { + error(accessExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion_1); + } + else { + var errorInfo = void 0; + if (indexType.flags & 1024) { + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType)); + } + else if (indexType.flags & 8192) { + var symbolName_2 = getFullyQualifiedName(indexType.symbol, accessExpression); + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName_2 + "]", typeToString(objectType)); + } + else if (indexType.flags & 128) { + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)); + } + else if (indexType.flags & 256) { + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)); + } + else if (indexType.flags & (8 | 4)) { + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType)); + } + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1, typeToString(fullIndexType), typeToString(objectType)); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo)); + } + } + } + } + return undefined; + } + } + if (isJSLiteralType(objectType)) { + return anyType; + } + if (accessNode) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + if (indexType.flags & (128 | 256)) { + error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType)); + } + else if (indexType.flags & (4 | 8)) { + error(indexNode, ts.Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType)); + } + else { + error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType)); + } + } + if (isTypeAny(indexType)) { + return indexType; + } + return undefined; + function errorIfWritingToReadonlyIndex(indexInfo) { + if (indexInfo && indexInfo.isReadonly && accessExpression && (ts.isAssignmentTarget(accessExpression) || ts.isDeleteTarget(accessExpression))) { + error(accessExpression, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType)); + } + } + } + function getIndexNodeForAccessExpression(accessNode) { + return accessNode.kind === 195 ? accessNode.argumentExpression : + accessNode.kind === 185 ? accessNode.indexType : + accessNode.kind === 154 ? accessNode.expression : + accessNode; + } + function isGenericObjectType(type) { + return maybeTypeOfKind(type, 58982400 | 131072); + } + function isGenericIndexType(type) { + return maybeTypeOfKind(type, 58982400 | 4194304); + } + function isThisTypeParameter(type) { + return !!(type.flags & 262144 && type.isThisType); + } + function getSimplifiedType(type, writing) { + return type.flags & 8388608 ? getSimplifiedIndexedAccessType(type, writing) : + type.flags & 16777216 ? getSimplifiedConditionalType(type, writing) : + type; + } + function distributeIndexOverObjectType(objectType, indexType, writing) { + if (objectType.flags & 3145728) { + var types = ts.map(objectType.types, function (t) { return getSimplifiedType(getIndexedAccessType(t, indexType), writing); }); + return objectType.flags & 2097152 || writing ? getIntersectionType(types) : getUnionType(types); + } + } + function distributeObjectOverIndexType(objectType, indexType, writing) { + if (indexType.flags & 1048576) { + var types = ts.map(indexType.types, function (t) { return getSimplifiedType(getIndexedAccessType(objectType, t), writing); }); + return writing ? getIntersectionType(types) : getUnionType(types); + } + } + function unwrapSubstitution(type) { + if (type.flags & 33554432) { + return type.substitute; + } + return type; + } + function getSimplifiedIndexedAccessType(type, writing) { + var cache = writing ? "simplifiedForWriting" : "simplifiedForReading"; + if (type[cache]) { + return type[cache] === circularConstraintType ? type : type[cache]; + } + type[cache] = circularConstraintType; + var objectType = unwrapSubstitution(getSimplifiedType(type.objectType, writing)); + var indexType = getSimplifiedType(type.indexType, writing); + var distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing); + if (distributedOverIndex) { + return type[cache] = distributedOverIndex; + } + if (!(indexType.flags & 63176704)) { + var distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing); + if (distributedOverObject) { + return type[cache] = distributedOverObject; + } + } + if (isGenericMappedType(objectType)) { + return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); }); + } + return type[cache] = type; + } + function getSimplifiedConditionalType(type, writing) { + var checkType = type.checkType; + var extendsType = type.extendsType; + var trueType = getTrueTypeFromConditionalType(type); + var falseType = getFalseTypeFromConditionalType(type); + if (falseType.flags & 131072 && getActualTypeVariable(trueType) === getActualTypeVariable(checkType)) { + if (checkType.flags & 1 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { + return getSimplifiedType(trueType, writing); + } + else if (isIntersectionEmpty(checkType, extendsType)) { + return neverType; + } + } + else if (trueType.flags & 131072 && getActualTypeVariable(falseType) === getActualTypeVariable(checkType)) { + if (!(checkType.flags & 1) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { + return neverType; + } + else if (checkType.flags & 1 || isIntersectionEmpty(checkType, extendsType)) { + return getSimplifiedType(falseType, writing); + } + } + return type; + } + function isIntersectionEmpty(type1, type2) { + return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072); + } + function substituteIndexedMappedType(objectType, index) { + var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]); + var templateMapper = combineTypeMappers(objectType.mapper, mapper); + return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper); + } + function getIndexedAccessType(objectType, indexType, accessNode) { + return getIndexedAccessTypeOrUndefined(objectType, indexType, accessNode, 0) || (accessNode ? errorType : unknownType); + } + function getIndexedAccessTypeOrUndefined(objectType, indexType, accessNode, accessFlags) { + if (accessFlags === void 0) { accessFlags = 0; } + if (objectType === wildcardType || indexType === wildcardType) { + return wildcardType; + } + if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 4 | 8)) { + indexType = stringType; + } + if (isGenericIndexType(indexType) || !(accessNode && accessNode.kind !== 185) && isGenericObjectType(objectType)) { + if (objectType.flags & 3) { + return objectType; + } + var id = objectType.id + "," + indexType.id; + var type = indexedAccessTypes.get(id); + if (!type) { + indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType)); + } + return type; + } + var apparentObjectType = getApparentType(objectType); + if (indexType.flags & 1048576 && !(indexType.flags & 16)) { + var propTypes = []; + var wasMissingProp = false; + for (var _i = 0, _a = indexType.types; _i < _a.length; _i++) { + var t = _a[_i]; + var propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, wasMissingProp, accessNode, accessFlags); + if (propType) { + propTypes.push(propType); + } + else if (!accessNode) { + return undefined; + } + else { + wasMissingProp = true; + } + } + if (wasMissingProp) { + return undefined; + } + return accessFlags & 2 ? getIntersectionType(propTypes) : getUnionType(propTypes); + } + return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, false, accessNode, accessFlags | 4); + } + function getTypeFromIndexedAccessTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var objectType = getTypeFromTypeNode(node.objectType); + var indexType = getTypeFromTypeNode(node.indexType); + var resolved = getIndexedAccessType(objectType, indexType, node); + links.resolvedType = resolved.flags & 8388608 && + resolved.objectType === objectType && + resolved.indexType === indexType ? + getConstrainedTypeVariable(resolved, node) : resolved; + } + return links.resolvedType; + } + function getTypeFromMappedTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var type = createObjectType(32, node.symbol); + type.declaration = node; + type.aliasSymbol = getAliasSymbolForTypeNode(node); + type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol); + links.resolvedType = type; + getConstraintTypeFromMappedType(type); + } + return links.resolvedType; + } + function getActualTypeVariable(type) { + if (type.flags & 33554432) { + return type.typeVariable; + } + if (type.flags & 8388608 && (type.objectType.flags & 33554432 || + type.indexType.flags & 33554432)) { + return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType)); + } + return type; + } + function getConditionalType(root, mapper) { + var checkType = instantiateType(root.checkType, mapper); + var extendsType = instantiateType(root.extendsType, mapper); + if (checkType === wildcardType || extendsType === wildcardType) { + return wildcardType; + } + var checkTypeInstantiable = maybeTypeOfKind(checkType, 63176704 | 131072); + var combinedMapper; + if (root.inferTypeParameters) { + var context = createInferenceContext(root.inferTypeParameters, undefined, 0); + if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) { + inferTypes(context.inferences, checkType, extendsType, 128 | 256); + } + combinedMapper = combineTypeMappers(mapper, context.mapper); + } + var inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType; + if (!checkTypeInstantiable && !maybeTypeOfKind(inferredExtendsType, 63176704 | 131072)) { + if (inferredExtendsType.flags & 3) { + return instantiateType(root.trueType, combinedMapper || mapper); + } + if (checkType.flags & 1) { + return getUnionType([instantiateType(root.trueType, combinedMapper || mapper), instantiateType(root.falseType, mapper)]); + } + if (!isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType))) { + return instantiateType(root.falseType, mapper); + } + if (isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) { + return instantiateType(root.trueType, combinedMapper || mapper); + } + } + var erasedCheckType = getActualTypeVariable(checkType); + var result = createType(16777216); + result.root = root; + result.checkType = erasedCheckType; + result.extendsType = extendsType; + result.mapper = mapper; + result.combinedMapper = combinedMapper; + result.aliasSymbol = root.aliasSymbol; + result.aliasTypeArguments = instantiateTypes(root.aliasTypeArguments, mapper); + return result; + } + function getTrueTypeFromConditionalType(type) { + return type.resolvedTrueType || (type.resolvedTrueType = instantiateType(type.root.trueType, type.mapper)); + } + function getFalseTypeFromConditionalType(type) { + return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(type.root.falseType, type.mapper)); + } + function getInferredTrueTypeFromConditionalType(type) { + return type.resolvedInferredTrueType || (type.resolvedInferredTrueType = type.combinedMapper ? instantiateType(type.root.trueType, type.combinedMapper) : getTrueTypeFromConditionalType(type)); + } + function getInferTypeParameters(node) { + var result; + if (node.locals) { + node.locals.forEach(function (symbol) { + if (symbol.flags & 262144) { + result = ts.append(result, getDeclaredTypeOfSymbol(symbol)); + } + }); + } + return result; + } + function getTypeFromConditionalTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var checkType = getTypeFromTypeNode(node.checkType); + var aliasSymbol = getAliasSymbolForTypeNode(node); + var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + var allOuterTypeParameters = getOuterTypeParameters(node, true); + var outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : ts.filter(allOuterTypeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, node); }); + var root = { + node: node, + checkType: checkType, + extendsType: getTypeFromTypeNode(node.extendsType), + trueType: getTypeFromTypeNode(node.trueType), + falseType: getTypeFromTypeNode(node.falseType), + isDistributive: !!(checkType.flags & 262144), + inferTypeParameters: getInferTypeParameters(node), + outerTypeParameters: outerTypeParameters, + instantiations: undefined, + aliasSymbol: aliasSymbol, + aliasTypeArguments: aliasTypeArguments + }; + links.resolvedType = getConditionalType(root, undefined); + if (outerTypeParameters) { + root.instantiations = ts.createMap(); + root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType); + } + } + return links.resolvedType; + } + function getTypeFromInferTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)); + } + return links.resolvedType; + } + function getIdentifierChain(node) { + if (ts.isIdentifier(node)) { + return [node]; + } + else { + return ts.append(getIdentifierChain(node.left), node.right); + } + } + function getTypeFromImportTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + if (node.isTypeOf && node.typeArguments) { + error(node, ts.Diagnostics.Type_arguments_cannot_be_used_here); + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + if (!ts.isLiteralImportTypeNode(node)) { + error(node.argument, ts.Diagnostics.String_literal_expected); + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + var targetMeaning = node.isTypeOf ? 111551 : node.flags & 4194304 ? 111551 | 788968 : 788968; + var innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal); + if (!innerModuleSymbol) { + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + var moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, false); + if (!ts.nodeIsMissing(node.qualifier)) { + var nameStack = getIdentifierChain(node.qualifier); + var currentNamespace = moduleSymbol; + var current = void 0; + while (current = nameStack.shift()) { + var meaning = nameStack.length ? 1920 : targetMeaning; + var next = getSymbol(getExportsOfSymbol(getMergedSymbol(resolveSymbol(currentNamespace))), current.escapedText, meaning); + if (!next) { + error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current)); + return links.resolvedType = errorType; + } + getNodeLinks(current).resolvedSymbol = next; + getNodeLinks(current.parent).resolvedSymbol = next; + currentNamespace = next; + } + links.resolvedType = resolveImportSymbolType(node, links, currentNamespace, targetMeaning); + } + else { + if (moduleSymbol.flags & targetMeaning) { + links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning); + } + else { + var errorMessage = targetMeaning === 111551 + ? ts.Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here + : ts.Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0; + error(node, errorMessage, node.argument.literal.text); + links.resolvedSymbol = unknownSymbol; + links.resolvedType = errorType; + } + } + } + return links.resolvedType; + } + function resolveImportSymbolType(node, links, symbol, meaning) { + var resolvedSymbol = resolveSymbol(symbol); + links.resolvedSymbol = resolvedSymbol; + if (meaning === 111551) { + return getTypeOfSymbol(symbol); + } + else { + return getTypeReferenceType(node, resolvedSymbol); + } + } + function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) { + links.resolvedType = emptyTypeLiteralType; + } + else { + var type = createObjectType(16, node.symbol); + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + if (ts.isJSDocTypeLiteral(node) && node.isArrayType) { + type = createArrayType(type); + } + links.resolvedType = type; + } + } + return links.resolvedType; + } + function getAliasSymbolForTypeNode(node) { + var host = node.parent; + while (ts.isParenthesizedTypeNode(host) || ts.isTypeOperatorNode(host) && host.operator === 138) { + host = host.parent; + } + return ts.isTypeAlias(host) ? getSymbolOfNode(host) : undefined; + } + function getTypeArgumentsForAliasSymbol(symbol) { + return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : undefined; + } + function isNonGenericObjectType(type) { + return !!(type.flags & 524288) && !isGenericMappedType(type); + } + function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) { + return isEmptyObjectType(type) || !!(type.flags & (65536 | 32768 | 528 | 296 | 2112 | 132 | 1056 | 67108864 | 4194304)); + } + function isSinglePropertyAnonymousObjectType(type) { + return !!(type.flags & 524288) && + !!(ts.getObjectFlags(type) & 16) && + (ts.length(getPropertiesOfType(type)) === 1 || ts.every(getPropertiesOfType(type), function (p) { return !!(p.flags & 16777216); })); + } + function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) { + if (type.types.length === 2) { + var firstType = type.types[0]; + var secondType = type.types[1]; + if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) { + return isEmptyObjectType(firstType) ? firstType : isEmptyObjectType(secondType) ? secondType : emptyObjectType; + } + if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType) && isSinglePropertyAnonymousObjectType(secondType)) { + return getAnonymousPartialType(secondType); + } + if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType) && isSinglePropertyAnonymousObjectType(firstType)) { + return getAnonymousPartialType(firstType); + } + } + function getAnonymousPartialType(type) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + if (ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16)) { + } + else if (isSpreadableProperty(prop)) { + var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768); + var flags = 4 | 16777216; + var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 0); + result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop); + result.declarations = prop.declarations; + result.nameType = getSymbolLinks(prop).nameType; + result.syntheticOrigin = prop; + members.set(prop.escapedName, result); + } + } + var spread = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoOfType(type, 0), getIndexInfoOfType(type, 1)); + spread.objectFlags |= 128 | 1048576; + return spread; + } + } + function getSpreadType(left, right, symbol, objectFlags, readonly) { + if (left.flags & 1 || right.flags & 1) { + return anyType; + } + if (left.flags & 2 || right.flags & 2) { + return unknownType; + } + if (left.flags & 131072) { + return right; + } + if (right.flags & 131072) { + return left; + } + if (left.flags & 1048576) { + var merged = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly); + if (merged) { + return getSpreadType(merged, right, symbol, objectFlags, readonly); + } + return mapType(left, function (t) { return getSpreadType(t, right, symbol, objectFlags, readonly); }); + } + if (right.flags & 1048576) { + var merged = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly); + if (merged) { + return getSpreadType(left, merged, symbol, objectFlags, readonly); + } + return mapType(right, function (t) { return getSpreadType(left, t, symbol, objectFlags, readonly); }); + } + if (right.flags & (528 | 296 | 2112 | 132 | 1056 | 67108864 | 4194304)) { + return left; + } + if (isGenericObjectType(left) || isGenericObjectType(right)) { + if (isEmptyObjectType(left)) { + return right; + } + if (left.flags & 2097152) { + var types = left.types; + var lastLeft = types[types.length - 1]; + if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) { + return getIntersectionType(ts.concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)])); + } + } + return getIntersectionType([left, right]); + } + var members = ts.createSymbolTable(); + var skippedPrivateMembers = ts.createUnderscoreEscapedMap(); + var stringIndexInfo; + var numberIndexInfo; + if (left === emptyObjectType) { + stringIndexInfo = getIndexInfoOfType(right, 0); + numberIndexInfo = getIndexInfoOfType(right, 1); + } + else { + stringIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 0), getIndexInfoOfType(right, 0)); + numberIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 1), getIndexInfoOfType(right, 1)); + } + for (var _i = 0, _a = getPropertiesOfType(right); _i < _a.length; _i++) { + var rightProp = _a[_i]; + if (ts.getDeclarationModifierFlagsFromSymbol(rightProp) & (8 | 16)) { + skippedPrivateMembers.set(rightProp.escapedName, true); + } + else if (isSpreadableProperty(rightProp)) { + members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly)); + } + } + for (var _b = 0, _c = getPropertiesOfType(left); _b < _c.length; _b++) { + var leftProp = _c[_b]; + if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) { + continue; + } + if (members.has(leftProp.escapedName)) { + var rightProp = members.get(leftProp.escapedName); + var rightType = getTypeOfSymbol(rightProp); + if (rightProp.flags & 16777216) { + var declarations = ts.concatenate(leftProp.declarations, rightProp.declarations); + var flags = 4 | (leftProp.flags & 16777216); + var result = createSymbol(flags, leftProp.escapedName); + result.type = getUnionType([getTypeOfSymbol(leftProp), getTypeWithFacts(rightType, 524288)]); + result.leftSpread = leftProp; + result.rightSpread = rightProp; + result.declarations = declarations; + result.nameType = getSymbolLinks(leftProp).nameType; + members.set(leftProp.escapedName, result); + } + } + else { + members.set(leftProp.escapedName, getSpreadSymbol(leftProp, readonly)); + } + } + var spread = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoWithReadonly(stringIndexInfo, readonly), getIndexInfoWithReadonly(numberIndexInfo, readonly)); + spread.objectFlags |= 128 | 1048576 | 1024 | objectFlags; + return spread; + } + function isSpreadableProperty(prop) { + return !ts.some(prop.declarations, ts.isPrivateIdentifierPropertyDeclaration) && + (!(prop.flags & (8192 | 32768 | 65536)) || + !prop.declarations.some(function (decl) { return ts.isClassLike(decl.parent); })); + } + function getSpreadSymbol(prop, readonly) { + var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768); + if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) { + return prop; + } + var flags = 4 | (prop.flags & 16777216); + var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 0); + result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop); + result.declarations = prop.declarations; + result.nameType = getSymbolLinks(prop).nameType; + result.syntheticOrigin = prop; + return result; + } + function getIndexInfoWithReadonly(info, readonly) { + return info && info.isReadonly !== readonly ? createIndexInfo(info.type, readonly, info.declaration) : info; + } + function createLiteralType(flags, value, symbol) { + var type = createType(flags); + type.symbol = symbol; + type.value = value; + return type; + } + function getFreshTypeOfLiteralType(type) { + if (type.flags & 2944) { + if (!type.freshType) { + var freshType = createLiteralType(type.flags, type.value, type.symbol); + freshType.regularType = type; + freshType.freshType = freshType; + type.freshType = freshType; + } + return type.freshType; + } + return type; + } + function getRegularTypeOfLiteralType(type) { + return type.flags & 2944 ? type.regularType : + type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getRegularTypeOfLiteralType)) : + type; + } + function isFreshLiteralType(type) { + return !!(type.flags & 2944) && type.freshType === type; + } + function getLiteralType(value, enumId, symbol) { + var qualifier = typeof value === "number" ? "#" : typeof value === "string" ? "@" : "n"; + var key = (enumId ? enumId : "") + qualifier + (typeof value === "object" ? ts.pseudoBigIntToString(value) : value); + var type = literalTypes.get(key); + if (!type) { + var flags = (typeof value === "number" ? 256 : + typeof value === "string" ? 128 : 2048) | + (enumId ? 1024 : 0); + literalTypes.set(key, type = createLiteralType(flags, value, symbol)); + type.regularType = type; + } + return type; + } + function getTypeFromLiteralTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal)); + } + return links.resolvedType; + } + function createUniqueESSymbolType(symbol) { + var type = createType(8192); + type.symbol = symbol; + type.escapedName = "__@" + type.symbol.escapedName + "@" + getSymbolId(type.symbol); + return type; + } + function getESSymbolLikeTypeForNode(node) { + if (ts.isValidESSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + var links = getSymbolLinks(symbol); + return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol)); + } + return esSymbolType; + } + function getThisType(node) { + var container = ts.getThisContainer(node, false); + var parent = container && container.parent; + if (parent && (ts.isClassLike(parent) || parent.kind === 246)) { + if (!ts.hasModifier(container, 32) && + (!ts.isConstructorDeclaration(container) || ts.isNodeDescendantOf(node, container.body))) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType; + } + } + if (parent && ts.isObjectLiteralExpression(parent) && ts.isBinaryExpression(parent.parent) && ts.getAssignmentDeclarationKind(parent.parent) === 6) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent.parent.left).parent).thisType; + } + var host = node.flags & 4194304 ? ts.getHostSignatureFromJSDoc(node) : undefined; + if (host && ts.isFunctionExpression(host) && ts.isBinaryExpression(host.parent) && ts.getAssignmentDeclarationKind(host.parent) === 3) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host.parent.left).parent).thisType; + } + if (isJSConstructor(container) && ts.isNodeDescendantOf(node, container.body)) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType; + } + error(node, ts.Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface); + return errorType; + } + function getTypeFromThisTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getThisType(node); + } + return links.resolvedType; + } + function getTypeFromTypeNode(node) { + switch (node.kind) { + case 125: + case 295: + case 296: + return anyType; + case 148: + return unknownType; + case 143: + return stringType; + case 140: + return numberType; + case 151: + return bigintType; + case 128: + return booleanType; + case 144: + return esSymbolType; + case 110: + return voidType; + case 146: + return undefinedType; + case 100: + return nullType; + case 137: + return neverType; + case 141: + return node.flags & 131072 && !noImplicitAny ? anyType : nonPrimitiveType; + case 183: + case 104: + return getTypeFromThisTypeNode(node); + case 187: + return getTypeFromLiteralTypeNode(node); + case 169: + return getTypeFromTypeReference(node); + case 168: + return node.assertsModifier ? voidType : booleanType; + case 216: + return getTypeFromTypeReference(node); + case 172: + return getTypeFromTypeQueryNode(node); + case 174: + case 175: + return getTypeFromArrayOrTupleTypeNode(node); + case 176: + return getTypeFromOptionalTypeNode(node); + case 178: + return getTypeFromUnionTypeNode(node); + case 179: + return getTypeFromIntersectionTypeNode(node); + case 297: + return getTypeFromJSDocNullableTypeNode(node); + case 299: + return addOptionality(getTypeFromTypeNode(node.type)); + case 182: + case 298: + case 294: + return getTypeFromTypeNode(node.type); + case 177: + return getElementTypeOfArrayType(getTypeFromTypeNode(node.type)) || errorType; + case 301: + return getTypeFromJSDocVariadicType(node); + case 170: + case 171: + case 173: + case 304: + case 300: + case 305: + return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + case 184: + return getTypeFromTypeOperatorNode(node); + case 185: + return getTypeFromIndexedAccessTypeNode(node); + case 186: + return getTypeFromMappedTypeNode(node); + case 180: + return getTypeFromConditionalTypeNode(node); + case 181: + return getTypeFromInferTypeNode(node); + case 188: + return getTypeFromImportTypeNode(node); + case 75: + case 153: + var symbol = getSymbolAtLocation(node); + return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType; + default: + return errorType; + } + } + function instantiateList(items, mapper, instantiator) { + if (items && items.length) { + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var mapped = instantiator(item, mapper); + if (item !== mapped) { + var result = i === 0 ? [] : items.slice(0, i); + result.push(mapped); + for (i++; i < items.length; i++) { + result.push(instantiator(items[i], mapper)); + } + return result; + } + } + } + return items; + } + function instantiateTypes(types, mapper) { + return instantiateList(types, mapper, instantiateType); + } + function instantiateSignatures(signatures, mapper) { + return instantiateList(signatures, mapper, instantiateSignature); + } + function makeUnaryTypeMapper(source, target) { + return function (t) { return t === source ? target : t; }; + } + function makeBinaryTypeMapper(source1, target1, source2, target2) { + return function (t) { return t === source1 ? target1 : t === source2 ? target2 : t; }; + } + function makeArrayTypeMapper(sources, targets) { + return function (t) { + for (var i = 0; i < sources.length; i++) { + if (t === sources[i]) { + return targets ? targets[i] : anyType; + } + } + return t; + }; + } + function createTypeMapper(sources, targets) { + ts.Debug.assert(targets === undefined || sources.length === targets.length); + return sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) : + sources.length === 2 ? makeBinaryTypeMapper(sources[0], targets ? targets[0] : anyType, sources[1], targets ? targets[1] : anyType) : + makeArrayTypeMapper(sources, targets); + } + function createTypeEraser(sources) { + return createTypeMapper(sources, undefined); + } + function createBackreferenceMapper(context, index) { + return function (t) { return ts.findIndex(context.inferences, function (info) { return info.typeParameter === t; }) >= index ? unknownType : t; }; + } + function combineTypeMappers(mapper1, mapper2) { + if (!mapper1) + return mapper2; + if (!mapper2) + return mapper1; + return function (t) { return instantiateType(mapper1(t), mapper2); }; + } + function createReplacementMapper(source, target, baseMapper) { + return function (t) { return t === source ? target : baseMapper(t); }; + } + function permissiveMapper(type) { + return type.flags & 262144 ? wildcardType : type; + } + function getRestrictiveTypeParameter(tp) { + return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol), + tp.restrictiveInstantiation.constraint = unknownType, + tp.restrictiveInstantiation); + } + function restrictiveMapper(type) { + return type.flags & 262144 ? getRestrictiveTypeParameter(type) : type; + } + function cloneTypeParameter(typeParameter) { + var result = createTypeParameter(typeParameter.symbol); + result.target = typeParameter; + return result; + } + function instantiateTypePredicate(predicate, mapper) { + return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper)); + } + function instantiateSignature(signature, mapper, eraseTypeParameters) { + var freshTypeParameters; + if (signature.typeParameters && !eraseTypeParameters) { + freshTypeParameters = ts.map(signature.typeParameters, cloneTypeParameter); + mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); + for (var _i = 0, freshTypeParameters_1 = freshTypeParameters; _i < freshTypeParameters_1.length; _i++) { + var tp = freshTypeParameters_1[_i]; + tp.mapper = mapper; + } + } + var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), undefined, undefined, signature.minArgumentCount, signature.flags & 3); + result.target = signature; + result.mapper = mapper; + return result; + } + function instantiateSymbol(symbol, mapper) { + var links = getSymbolLinks(symbol); + if (links.type && !maybeTypeOfKind(links.type, 524288 | 63176704)) { + return symbol; + } + if (ts.getCheckFlags(symbol) & 1) { + symbol = links.target; + mapper = combineTypeMappers(links.mapper, mapper); + } + var result = createSymbol(symbol.flags, symbol.escapedName, 1 | ts.getCheckFlags(symbol) & (8 | 4096 | 16384 | 32768)); + result.declarations = symbol.declarations; + result.parent = symbol.parent; + result.target = symbol; + result.mapper = mapper; + if (symbol.valueDeclaration) { + result.valueDeclaration = symbol.valueDeclaration; + } + if (links.nameType) { + result.nameType = links.nameType; + } + return result; + } + function getObjectTypeInstantiation(type, mapper) { + var target = type.objectFlags & 64 ? type.target : type; + var node = type.objectFlags & 4 ? type.node : type.symbol.declarations[0]; + var links = getNodeLinks(node); + var typeParameters = links.outerTypeParameters; + if (!typeParameters) { + var declaration_1 = node; + if (ts.isInJSFile(declaration_1)) { + var paramTag = ts.findAncestor(declaration_1, ts.isJSDocParameterTag); + if (paramTag) { + var paramSymbol = ts.getParameterSymbolFromJSDoc(paramTag); + if (paramSymbol) { + declaration_1 = paramSymbol.valueDeclaration; + } + } + } + var outerTypeParameters = getOuterTypeParameters(declaration_1, true); + if (isJSConstructor(declaration_1)) { + var templateTagParameters = getTypeParametersFromDeclaration(declaration_1); + outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters); + } + typeParameters = outerTypeParameters || ts.emptyArray; + typeParameters = (target.objectFlags & 4 || target.symbol.flags & 2048) && !target.aliasTypeArguments ? + ts.filter(typeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, declaration_1); }) : + typeParameters; + links.outerTypeParameters = typeParameters; + if (typeParameters.length) { + links.instantiations = ts.createMap(); + links.instantiations.set(getTypeListId(typeParameters), target); + } + } + if (typeParameters.length) { + var typeArguments = ts.map(typeParameters, combineTypeMappers(type.mapper, mapper)); + var id = getTypeListId(typeArguments); + var result = links.instantiations.get(id); + if (!result) { + var newMapper = createTypeMapper(typeParameters, typeArguments); + result = target.objectFlags & 4 ? createDeferredTypeReference(type.target, type.node, newMapper) : + target.objectFlags & 32 ? instantiateMappedType(target, newMapper) : + instantiateAnonymousType(target, newMapper); + links.instantiations.set(id, result); + } + return result; + } + return type; + } + function maybeTypeParameterReference(node) { + return !(node.kind === 153 || + node.parent.kind === 169 && node.parent.typeArguments && node === node.parent.typeName || + node.parent.kind === 188 && node.parent.typeArguments && node === node.parent.qualifier); + } + function isTypeParameterPossiblyReferenced(tp, node) { + if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) { + var container = tp.symbol.declarations[0].parent; + for (var n = node; n !== container; n = n.parent) { + if (!n || n.kind === 223 || n.kind === 180 && ts.forEachChild(n.extendsType, containsReference)) { + return true; + } + } + return !!ts.forEachChild(node, containsReference); + } + return true; + function containsReference(node) { + switch (node.kind) { + case 183: + return !!tp.isThisType; + case 75: + return !tp.isThisType && ts.isPartOfTypeNode(node) && maybeTypeParameterReference(node) && + getTypeFromTypeNode(node) === tp; + case 172: + return true; + } + return !!ts.forEachChild(node, containsReference); + } + } + function getHomomorphicTypeVariable(type) { + var constraintType = getConstraintTypeFromMappedType(type); + if (constraintType.flags & 4194304) { + var typeVariable = getActualTypeVariable(constraintType.type); + if (typeVariable.flags & 262144) { + return typeVariable; + } + } + return undefined; + } + function instantiateMappedType(type, mapper) { + var typeVariable = getHomomorphicTypeVariable(type); + if (typeVariable) { + var mappedTypeVariable = instantiateType(typeVariable, mapper); + if (typeVariable !== mappedTypeVariable) { + return mapType(mappedTypeVariable, function (t) { + if (t.flags & (3 | 58982400 | 524288 | 2097152) && t !== wildcardType && t !== errorType) { + var replacementMapper = createReplacementMapper(typeVariable, t, mapper); + return isArrayType(t) ? instantiateMappedArrayType(t, type, replacementMapper) : + isTupleType(t) ? instantiateMappedTupleType(t, type, replacementMapper) : + instantiateAnonymousType(type, replacementMapper); + } + return t; + }); + } + } + return instantiateAnonymousType(type, mapper); + } + function getModifiedReadonlyState(state, modifiers) { + return modifiers & 1 ? true : modifiers & 2 ? false : state; + } + function instantiateMappedArrayType(arrayType, mappedType, mapper) { + var elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper); + return elementType === errorType ? errorType : + createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType))); + } + function instantiateMappedTupleType(tupleType, mappedType, mapper) { + var minLength = tupleType.target.minLength; + var elementTypes = ts.map(getTypeArguments(tupleType), function (_, i) { + return instantiateMappedTypeTemplate(mappedType, getLiteralType("" + i), i >= minLength, mapper); + }); + var modifiers = getMappedTypeModifiers(mappedType); + var newMinLength = modifiers & 4 ? 0 : + modifiers & 8 ? getTypeReferenceArity(tupleType) - (tupleType.target.hasRestElement ? 1 : 0) : + minLength; + var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers); + return ts.contains(elementTypes, errorType) ? errorType : + createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); + } + function instantiateMappedTypeTemplate(type, key, isOptional, mapper) { + var templateMapper = combineTypeMappers(mapper, createTypeMapper([getTypeParameterFromMappedType(type)], [key])); + var propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper); + var modifiers = getMappedTypeModifiers(type); + return strictNullChecks && modifiers & 4 && !isTypeAssignableTo(undefinedType, propType) ? getOptionalType(propType) : + strictNullChecks && modifiers & 8 && isOptional ? getTypeWithFacts(propType, 524288) : + propType; + } + function instantiateAnonymousType(type, mapper) { + var result = createObjectType(type.objectFlags | 64, type.symbol); + if (type.objectFlags & 32) { + result.declaration = type.declaration; + var origTypeParameter = getTypeParameterFromMappedType(type); + var freshTypeParameter = cloneTypeParameter(origTypeParameter); + result.typeParameter = freshTypeParameter; + mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper); + freshTypeParameter.mapper = mapper; + } + result.target = type; + result.mapper = mapper; + result.aliasSymbol = type.aliasSymbol; + result.aliasTypeArguments = instantiateTypes(type.aliasTypeArguments, mapper); + return result; + } + function getConditionalTypeInstantiation(type, mapper) { + var root = type.root; + if (root.outerTypeParameters) { + var typeArguments = ts.map(root.outerTypeParameters, mapper); + var id = getTypeListId(typeArguments); + var result = root.instantiations.get(id); + if (!result) { + var newMapper = createTypeMapper(root.outerTypeParameters, typeArguments); + result = instantiateConditionalType(root, newMapper); + root.instantiations.set(id, result); + } + return result; + } + return type; + } + function instantiateConditionalType(root, mapper) { + if (root.isDistributive) { + var checkType_1 = root.checkType; + var instantiatedType = mapper(checkType_1); + if (checkType_1 !== instantiatedType && instantiatedType.flags & (1048576 | 131072)) { + return mapType(instantiatedType, function (t) { return getConditionalType(root, createReplacementMapper(checkType_1, t, mapper)); }); + } + } + return getConditionalType(root, mapper); + } + function instantiateType(type, mapper) { + if (!type || !mapper || mapper === identityMapper) { + return type; + } + if (instantiationDepth === 50 || instantiationCount >= 5000000) { + error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); + return errorType; + } + instantiationCount++; + instantiationDepth++; + var result = instantiateTypeWorker(type, mapper); + instantiationDepth--; + return result; + } + function instantiateTypeWorker(type, mapper) { + var flags = type.flags; + if (flags & 262144) { + return mapper(type); + } + if (flags & 524288) { + var objectFlags = type.objectFlags; + if (objectFlags & 16) { + return couldContainTypeVariables(type) ? + getObjectTypeInstantiation(type, mapper) : type; + } + if (objectFlags & 32) { + return getObjectTypeInstantiation(type, mapper); + } + if (objectFlags & 4) { + if (type.node) { + return getObjectTypeInstantiation(type, mapper); + } + var resolvedTypeArguments = type.resolvedTypeArguments; + var newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); + return newTypeArguments !== resolvedTypeArguments ? createTypeReference(type.target, newTypeArguments) : type; + } + return type; + } + if (flags & 1048576 && !(flags & 131068)) { + var types = type.types; + var newTypes = instantiateTypes(types, mapper); + return newTypes !== types ? getUnionType(newTypes, 1, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type; + } + if (flags & 2097152) { + var types = type.types; + var newTypes = instantiateTypes(types, mapper); + return newTypes !== types ? getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type; + } + if (flags & 4194304) { + return getIndexType(instantiateType(type.type, mapper)); + } + if (flags & 8388608) { + return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper)); + } + if (flags & 16777216) { + return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper)); + } + if (flags & 33554432) { + var maybeVariable = instantiateType(type.typeVariable, mapper); + if (maybeVariable.flags & 8650752) { + return getSubstitutionType(maybeVariable, instantiateType(type.substitute, mapper)); + } + else { + var sub = instantiateType(type.substitute, mapper); + if (sub.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(maybeVariable), getRestrictiveInstantiation(sub))) { + return maybeVariable; + } + return sub; + } + } + return type; + } + function getPermissiveInstantiation(type) { + return type.flags & (131068 | 3 | 131072) ? type : + type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper)); + } + function getRestrictiveInstantiation(type) { + if (type.flags & (131068 | 3 | 131072)) { + return type; + } + if (type.restrictiveInstantiation) { + return type.restrictiveInstantiation; + } + type.restrictiveInstantiation = instantiateType(type, restrictiveMapper); + type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation; + return type.restrictiveInstantiation; + } + function instantiateIndexInfo(info, mapper) { + return info && createIndexInfo(instantiateType(info.type, mapper), info.isReadonly, info.declaration); + } + function isContextSensitive(node) { + ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node)); + switch (node.kind) { + case 201: + case 202: + case 161: + case 244: + return isContextSensitiveFunctionLikeDeclaration(node); + case 193: + return ts.some(node.properties, isContextSensitive); + case 192: + return ts.some(node.elements, isContextSensitive); + case 210: + return isContextSensitive(node.whenTrue) || + isContextSensitive(node.whenFalse); + case 209: + return (node.operatorToken.kind === 56 || node.operatorToken.kind === 60) && + (isContextSensitive(node.left) || isContextSensitive(node.right)); + case 281: + return isContextSensitive(node.initializer); + case 200: + return isContextSensitive(node.expression); + case 274: + return ts.some(node.properties, isContextSensitive) || ts.isJsxOpeningElement(node.parent) && ts.some(node.parent.parent.children, isContextSensitive); + case 273: { + var initializer = node.initializer; + return !!initializer && isContextSensitive(initializer); + } + case 276: { + var expression = node.expression; + return !!expression && isContextSensitive(expression); + } + } + return false; + } + function isContextSensitiveFunctionLikeDeclaration(node) { + return (!ts.isFunctionDeclaration(node) || ts.isInJSFile(node) && !!getTypeForDeclarationFromJSDocComment(node)) && + (hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node)); + } + function hasContextSensitiveParameters(node) { + if (!node.typeParameters) { + if (ts.some(node.parameters, function (p) { return !ts.getEffectiveTypeAnnotationNode(p); })) { + return true; + } + if (node.kind !== 202) { + var parameter = ts.firstOrUndefined(node.parameters); + if (!(parameter && ts.parameterIsThisKeyword(parameter))) { + return true; + } + } + } + return false; + } + function hasContextSensitiveReturnExpression(node) { + return !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 223 && isContextSensitive(node.body); + } + function isContextSensitiveFunctionOrObjectLiteralMethod(func) { + return (ts.isInJSFile(func) && ts.isFunctionDeclaration(func) || isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) && + isContextSensitiveFunctionLikeDeclaration(func); + } + function getTypeWithoutSignatures(type) { + if (type.flags & 524288) { + var resolved = resolveStructuredTypeMembers(type); + if (resolved.constructSignatures.length || resolved.callSignatures.length) { + var result = createObjectType(16, type.symbol); + result.members = resolved.members; + result.properties = resolved.properties; + result.callSignatures = ts.emptyArray; + result.constructSignatures = ts.emptyArray; + return result; + } + } + else if (type.flags & 2097152) { + return getIntersectionType(ts.map(type.types, getTypeWithoutSignatures)); + } + return type; + } + function isTypeIdenticalTo(source, target) { + return isTypeRelatedTo(source, target, identityRelation); + } + function compareTypesIdentical(source, target) { + return isTypeRelatedTo(source, target, identityRelation) ? -1 : 0; + } + function compareTypesAssignable(source, target) { + return isTypeRelatedTo(source, target, assignableRelation) ? -1 : 0; + } + function compareTypesSubtypeOf(source, target) { + return isTypeRelatedTo(source, target, subtypeRelation) ? -1 : 0; + } + function isTypeSubtypeOf(source, target) { + return isTypeRelatedTo(source, target, subtypeRelation); + } + function isTypeAssignableTo(source, target) { + return isTypeRelatedTo(source, target, assignableRelation); + } + function isTypeDerivedFrom(source, target) { + return source.flags & 1048576 ? ts.every(source.types, function (t) { return isTypeDerivedFrom(t, target); }) : + target.flags & 1048576 ? ts.some(target.types, function (t) { return isTypeDerivedFrom(source, t); }) : + source.flags & 58982400 ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) : + target === globalObjectType ? !!(source.flags & (524288 | 67108864)) : + target === globalFunctionType ? !!(source.flags & 524288) && isFunctionObjectType(source) : + hasBaseType(source, getTargetType(target)); + } + function isTypeComparableTo(source, target) { + return isTypeRelatedTo(source, target, comparableRelation); + } + function areTypesComparable(type1, type2) { + return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1); + } + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain, errorOutputObject) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain, errorOutputObject); + } + function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) { + return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, undefined); + } + function checkTypeRelatedToAndOptionallyElaborate(source, target, relation, errorNode, expr, headMessage, containingMessageChain, errorOutputContainer) { + if (isTypeRelatedTo(source, target, relation)) + return true; + if (!errorNode || !elaborateError(expr, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) { + return checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer); + } + return false; + } + function isOrHasGenericConditional(type) { + return !!(type.flags & 16777216 || (type.flags & 2097152 && ts.some(type.types, isOrHasGenericConditional))); + } + function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) { + if (!node || isOrHasGenericConditional(target)) + return false; + if (!checkTypeRelatedTo(source, target, relation, undefined) + && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) { + return true; + } + switch (node.kind) { + case 276: + case 200: + return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer); + case 209: + switch (node.operatorToken.kind) { + case 62: + case 27: + return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer); + } + break; + case 193: + return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 192: + return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 274: + return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 202: + return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer); + } + return false; + } + function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) { + var callSignatures = getSignaturesOfType(source, 0); + var constructSignatures = getSignaturesOfType(source, 1); + for (var _i = 0, _a = [constructSignatures, callSignatures]; _i < _a.length; _i++) { + var signatures = _a[_i]; + if (ts.some(signatures, function (s) { + var returnType = getReturnTypeOfSignature(s); + return !(returnType.flags & (1 | 131072)) && checkTypeRelatedTo(returnType, target, relation, undefined); + })) { + var resultObj = errorOutputContainer || {}; + checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj); + var diagnostic = resultObj.errors[resultObj.errors.length - 1]; + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(node, signatures === constructSignatures ? ts.Diagnostics.Did_you_mean_to_use_new_with_this_expression : ts.Diagnostics.Did_you_mean_to_call_this_expression)); + return true; + } + } + return false; + } + function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) { + if (ts.isBlock(node.body)) { + return false; + } + if (ts.some(node.parameters, ts.hasType)) { + return false; + } + var sourceSig = getSingleCallSignature(source); + if (!sourceSig) { + return false; + } + var targetSignatures = getSignaturesOfType(target, 0); + if (!ts.length(targetSignatures)) { + return false; + } + var returnExpression = node.body; + var sourceReturn = getReturnTypeOfSignature(sourceSig); + var targetReturn = getUnionType(ts.map(targetSignatures, getReturnTypeOfSignature)); + if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, undefined)) { + var elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, undefined, containingMessageChain, errorOutputContainer); + if (elaborated) { + return elaborated; + } + var resultObj = errorOutputContainer || {}; + checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, undefined, containingMessageChain, resultObj); + if (resultObj.errors) { + if (target.symbol && ts.length(target.symbol.declarations)) { + ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(target.symbol.declarations[0], ts.Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature)); + } + return true; + } + } + return false; + } + function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) { + var idx = getIndexedAccessTypeOrUndefined(target, nameType); + if (idx) { + return idx; + } + if (target.flags & 1048576) { + var best = getBestMatchingType(source, target); + if (best) { + return getIndexedAccessTypeOrUndefined(best, nameType); + } + } + } + function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) { + var reportedError = false; + for (var status = iterator.next(); !status.done; status = iterator.next()) { + var _a = status.value, prop = _a.errorNode, next = _a.innerExpression, nameType = _a.nameType, errorMessage = _a.errorMessage; + var targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType); + if (!targetPropType || targetPropType.flags & 8388608) + continue; + var sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType); + if (sourcePropType && !checkTypeRelatedTo(sourcePropType, targetPropType, relation, undefined)) { + var elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, undefined, containingMessageChain, errorOutputContainer); + if (elaborated) { + reportedError = true; + } + else { + var resultObj = errorOutputContainer || {}; + var specificSource = next ? checkExpressionForMutableLocation(next, 0, sourcePropType) : sourcePropType; + var result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj); + if (result && specificSource !== sourcePropType) { + checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj); + } + if (resultObj.errors) { + var reportedDiag = resultObj.errors[resultObj.errors.length - 1]; + var propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined; + var targetProp = propertyName !== undefined ? getPropertyOfType(target, propertyName) : undefined; + var issuedElaboration = false; + if (!targetProp) { + var indexInfo = isTypeAssignableToKind(nameType, 296) && getIndexInfoOfType(target, 1) || + getIndexInfoOfType(target, 0) || + undefined; + if (indexInfo && indexInfo.declaration && !ts.getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) { + issuedElaboration = true; + ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(indexInfo.declaration, ts.Diagnostics.The_expected_type_comes_from_this_index_signature)); + } + } + if (!issuedElaboration && (targetProp && ts.length(targetProp.declarations) || target.symbol && ts.length(target.symbol.declarations))) { + var targetNode = targetProp && ts.length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0]; + if (!ts.getSourceFileOfNode(targetNode).hasNoDefaultLib) { + ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(targetNode, ts.Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1, propertyName && !(nameType.flags & 8192) ? ts.unescapeLeadingUnderscores(propertyName) : typeToString(nameType), typeToString(target))); + } + } + } + reportedError = true; + } + } + } + return reportedError; + } + function generateJsxAttributes(node) { + var _i, _a, prop; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!ts.length(node.properties)) + return [2]; + _i = 0, _a = node.properties; + _b.label = 1; + case 1: + if (!(_i < _a.length)) return [3, 4]; + prop = _a[_i]; + if (ts.isJsxSpreadAttribute(prop)) + return [3, 3]; + return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: getLiteralType(ts.idText(prop.name)) }]; + case 2: + _b.sent(); + _b.label = 3; + case 3: + _i++; + return [3, 1]; + case 4: return [2]; + } + }); + } + function generateJsxChildren(node, getInvalidTextDiagnostic) { + var memberOffset, i, child, nameType, elem; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!ts.length(node.children)) + return [2]; + memberOffset = 0; + i = 0; + _a.label = 1; + case 1: + if (!(i < node.children.length)) return [3, 5]; + child = node.children[i]; + nameType = getLiteralType(i - memberOffset); + elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic); + if (!elem) return [3, 3]; + return [4, elem]; + case 2: + _a.sent(); + return [3, 4]; + case 3: + memberOffset++; + _a.label = 4; + case 4: + i++; + return [3, 1]; + case 5: return [2]; + } + }); + } + function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) { + switch (child.kind) { + case 276: + return { errorNode: child, innerExpression: child.expression, nameType: nameType }; + case 11: + if (child.containsOnlyTriviaWhiteSpaces) { + break; + } + return { errorNode: child, innerExpression: undefined, nameType: nameType, errorMessage: getInvalidTextDiagnostic() }; + case 266: + case 267: + case 270: + return { errorNode: child, innerExpression: child, nameType: nameType }; + default: + return ts.Debug.assertNever(child, "Found invalid jsx child"); + } + } + function getSemanticJsxChildren(children) { + return ts.filter(children, function (i) { return !ts.isJsxText(i) || !i.containsOnlyTriviaWhiteSpaces; }); + } + function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) { + var result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer); + var invalidTextDiagnostic; + if (ts.isJsxOpeningElement(node.parent) && ts.isJsxElement(node.parent.parent)) { + var containingElement = node.parent.parent; + var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName); + var childrenNameType = getLiteralType(childrenPropName); + var childrenTargetType = getIndexedAccessType(target, childrenNameType); + var validChildren = getSemanticJsxChildren(containingElement.children); + if (!ts.length(validChildren)) { + return result; + } + var moreThanOneRealChildren = ts.length(validChildren) > 1; + var arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType); + var nonArrayLikeTargetParts = filterType(childrenTargetType, function (t) { return !isArrayOrTupleLikeType(t); }); + if (moreThanOneRealChildren) { + if (arrayLikeTargetParts !== neverType) { + var realSource = createTupleType(checkJsxChildren(containingElement, 0)); + var children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic); + result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result; + } + else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) { + result = true; + var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided, childrenPropName, typeToString(childrenTargetType)); + if (errorOutputContainer && errorOutputContainer.skipLogging) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + } + else { + if (nonArrayLikeTargetParts !== neverType) { + var child = validChildren[0]; + var elem_1 = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic); + if (elem_1) { + result = elaborateElementwise((function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4, elem_1]; + case 1: + _a.sent(); + return [2]; + } + }); })(), source, target, relation, containingMessageChain, errorOutputContainer) || result; + } + } + else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) { + result = true; + var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided, childrenPropName, typeToString(childrenTargetType)); + if (errorOutputContainer && errorOutputContainer.skipLogging) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + } + } + return result; + function getInvalidTextualChildDiagnostic() { + if (!invalidTextDiagnostic) { + var tagNameText = ts.getTextOfNode(node.parent.tagName); + var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName); + var childrenTargetType = getIndexedAccessType(target, getLiteralType(childrenPropName)); + var diagnostic = ts.Diagnostics._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2; + invalidTextDiagnostic = __assign(__assign({}, diagnostic), { key: "!!ALREADY FORMATTED!!", message: ts.formatMessage(undefined, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) }); + } + return invalidTextDiagnostic; + } + } + function generateLimitedTupleElements(node, target) { + var len, i, elem, nameType; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + len = ts.length(node.elements); + if (!len) + return [2]; + i = 0; + _a.label = 1; + case 1: + if (!(i < len)) return [3, 4]; + if (isTupleLikeType(target) && !getPropertyOfType(target, ("" + i))) + return [3, 3]; + elem = node.elements[i]; + if (ts.isOmittedExpression(elem)) + return [3, 3]; + nameType = getLiteralType(i); + return [4, { errorNode: elem, innerExpression: elem, nameType: nameType }]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + i++; + return [3, 1]; + case 4: return [2]; + } + }); + } + function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) { + if (target.flags & 131068) + return false; + if (isTupleLikeType(source)) { + return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer); + } + var tupleizedType = checkArrayLiteral(node, 1, true); + if (isTupleLikeType(tupleizedType)) { + return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer); + } + return false; + } + function generateObjectLiteralElements(node) { + var _i, _a, prop, type, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + if (!ts.length(node.properties)) + return [2]; + _i = 0, _a = node.properties; + _c.label = 1; + case 1: + if (!(_i < _a.length)) return [3, 8]; + prop = _a[_i]; + if (ts.isSpreadAssignment(prop)) + return [3, 7]; + type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576); + if (!type || (type.flags & 131072)) { + return [3, 7]; + } + _b = prop.kind; + switch (_b) { + case 164: return [3, 2]; + case 163: return [3, 2]; + case 161: return [3, 2]; + case 282: return [3, 2]; + case 281: return [3, 4]; + } + return [3, 6]; + case 2: return [4, { errorNode: prop.name, innerExpression: undefined, nameType: type }]; + case 3: + _c.sent(); + return [3, 7]; + case 4: return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: isComputedNonLiteralName(prop.name) ? ts.Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : undefined }]; + case 5: + _c.sent(); + return [3, 7]; + case 6: + ts.Debug.assertNever(prop); + _c.label = 7; + case 7: + _i++; + return [3, 1]; + case 8: return [2]; + } + }); + } + function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) { + if (target.flags & 131068) + return false; + return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer); + } + function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain); + } + function isSignatureAssignableTo(source, target, ignoreReturnTypes) { + return compareSignaturesRelated(source, target, ignoreReturnTypes ? 4 : 0, false, undefined, undefined, compareTypesAssignable, undefined) !== 0; + } + function isAnySignature(s) { + return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && + signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && + isTypeAny(getReturnTypeOfSignature(s)); + } + function compareSignaturesRelated(source, target, checkMode, reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) { + if (source === target) { + return -1; + } + if (isAnySignature(target)) { + return -1; + } + var targetCount = getParameterCount(target); + var sourceHasMoreParameters = !hasEffectiveRestParameter(target) && + (checkMode & 8 ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount); + if (sourceHasMoreParameters) { + return 0; + } + if (source.typeParameters && source.typeParameters !== target.typeParameters) { + target = getCanonicalSignature(target); + source = instantiateSignatureInContextOf(source, target, undefined, compareTypes); + } + var sourceCount = getParameterCount(source); + var sourceRestType = getNonArrayRestType(source); + var targetRestType = getNonArrayRestType(target); + if (sourceRestType || targetRestType) { + void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers); + } + if (sourceRestType && targetRestType && sourceCount !== targetCount) { + return 0; + } + var kind = target.declaration ? target.declaration.kind : 0; + var strictVariance = !(checkMode & 3) && strictFunctionTypes && kind !== 161 && + kind !== 160 && kind !== 162; + var result = -1; + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType && sourceThisType !== voidType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + var related = !strictVariance && compareTypes(sourceThisType, targetThisType, false) + || compareTypes(targetThisType, sourceThisType, reportErrors); + if (!related) { + if (reportErrors) { + errorReporter(ts.Diagnostics.The_this_types_of_each_signature_are_incompatible); + } + return 0; + } + result &= related; + } + } + var paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount); + var restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1; + for (var i = 0; i < paramCount; i++) { + var sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : getTypeAtPosition(source, i); + var targetType = i === restIndex ? getRestTypeAtPosition(target, i) : getTypeAtPosition(target, i); + var sourceSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(sourceType)); + var targetSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(targetType)); + var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && + (getFalsyFlags(sourceType) & 98304) === (getFalsyFlags(targetType) & 98304); + var related = callbacks ? + compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8) | (strictVariance ? 2 : 1), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : + !(checkMode & 3) && !strictVariance && compareTypes(sourceType, targetType, false) || compareTypes(targetType, sourceType, reportErrors); + if (related && checkMode & 8 && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, false)) { + related = 0; + } + if (!related) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, ts.unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)), ts.unescapeLeadingUnderscores(getParameterNameAtPosition(target, i))); + } + return 0; + } + result &= related; + } + if (!(checkMode & 4)) { + var targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType + : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol)) + : getReturnTypeOfSignature(target); + if (targetReturnType === voidType) { + return result; + } + var sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType + : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol)) + : getReturnTypeOfSignature(source); + var targetTypePredicate = getTypePredicateOfSignature(target); + if (targetTypePredicate) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + if (sourceTypePredicate) { + result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors, errorReporter, compareTypes); + } + else if (ts.isIdentifierTypePredicate(targetTypePredicate)) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source)); + } + return 0; + } + } + else { + result &= checkMode & 1 && compareTypes(targetReturnType, sourceReturnType, false) || + compareTypes(sourceReturnType, targetReturnType, reportErrors); + if (!result && reportErrors && incompatibleErrorReporter) { + incompatibleErrorReporter(sourceReturnType, targetReturnType); + } + } + } + return result; + } + function compareTypePredicateRelatedTo(source, target, reportErrors, errorReporter, compareTypes) { + if (source.kind !== target.kind) { + if (reportErrors) { + errorReporter(ts.Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard); + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return 0; + } + if (source.kind === 1 || source.kind === 3) { + if (source.parameterIndex !== target.parameterIndex) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName); + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return 0; + } + } + var related = source.type === target.type ? -1 : + source.type && target.type ? compareTypes(source.type, target.type, reportErrors) : + 0; + if (related === 0 && reportErrors) { + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return related; + } + function isImplementationCompatibleWithOverload(implementation, overload) { + var erasedSource = getErasedSignature(implementation); + var erasedTarget = getErasedSignature(overload); + var sourceReturnType = getReturnTypeOfSignature(erasedSource); + var targetReturnType = getReturnTypeOfSignature(erasedTarget); + if (targetReturnType === voidType + || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation) + || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) { + return isSignatureAssignableTo(erasedSource, erasedTarget, true); + } + return false; + } + function isEmptyResolvedType(t) { + return t !== anyFunctionType && + t.properties.length === 0 && + t.callSignatures.length === 0 && + t.constructSignatures.length === 0 && + !t.stringIndexInfo && + !t.numberIndexInfo; + } + function isEmptyObjectType(type) { + return type.flags & 524288 ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) : + type.flags & 67108864 ? true : + type.flags & 1048576 ? ts.some(type.types, isEmptyObjectType) : + type.flags & 2097152 ? ts.every(type.types, isEmptyObjectType) : + false; + } + function isEmptyAnonymousObjectType(type) { + return !!(ts.getObjectFlags(type) & 16) && isEmptyObjectType(type); + } + function isStringIndexSignatureOnlyType(type) { + return type.flags & 524288 && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfoOfType(type, 0) && !getIndexInfoOfType(type, 1) || + type.flags & 3145728 && ts.every(type.types, isStringIndexSignatureOnlyType) || + false; + } + function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) { + if (sourceSymbol === targetSymbol) { + return true; + } + var id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol); + var entry = enumRelation.get(id); + if (entry !== undefined && !(!(entry & 4) && entry & 2 && errorReporter)) { + return !!(entry & 1); + } + if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256) || !(targetSymbol.flags & 256)) { + enumRelation.set(id, 2 | 4); + return false; + } + var targetEnumType = getTypeOfSymbol(targetSymbol); + for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(sourceSymbol)); _i < _a.length; _i++) { + var property = _a[_i]; + if (property.flags & 8) { + var targetProperty = getPropertyOfType(targetEnumType, property.escapedName); + if (!targetProperty || !(targetProperty.flags & 8)) { + if (errorReporter) { + errorReporter(ts.Diagnostics.Property_0_is_missing_in_type_1, ts.symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64)); + enumRelation.set(id, 2 | 4); + } + else { + enumRelation.set(id, 2); + } + return false; + } + } + } + enumRelation.set(id, 1); + return true; + } + function isSimpleTypeRelatedTo(source, target, relation, errorReporter) { + var s = source.flags; + var t = target.flags; + if (t & 3 || s & 131072 || source === wildcardType) + return true; + if (t & 131072) + return false; + if (s & 132 && t & 4) + return true; + if (s & 128 && s & 1024 && + t & 128 && !(t & 1024) && + source.value === target.value) + return true; + if (s & 296 && t & 8) + return true; + if (s & 256 && s & 1024 && + t & 256 && !(t & 1024) && + source.value === target.value) + return true; + if (s & 2112 && t & 64) + return true; + if (s & 528 && t & 16) + return true; + if (s & 12288 && t & 4096) + return true; + if (s & 32 && t & 32 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) + return true; + if (s & 1024 && t & 1024) { + if (s & 1048576 && t & 1048576 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) + return true; + if (s & 2944 && t & 2944 && + source.value === target.value && + isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter)) + return true; + } + if (s & 32768 && (!strictNullChecks || t & (32768 | 16384))) + return true; + if (s & 65536 && (!strictNullChecks || t & 65536)) + return true; + if (s & 524288 && t & 67108864) + return true; + if (relation === assignableRelation || relation === comparableRelation) { + if (s & 1) + return true; + if (s & (8 | 256) && !(s & 1024) && (t & 32 || t & 256 && t & 1024)) + return true; + } + return false; + } + function isTypeRelatedTo(source, target, relation) { + if (isFreshLiteralType(source)) { + source = source.regularType; + } + if (isFreshLiteralType(target)) { + target = target.regularType; + } + if (source === target || + relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) || + relation !== identityRelation && isSimpleTypeRelatedTo(source, target, relation)) { + return true; + } + if (source.flags & 524288 && target.flags & 524288) { + var related = relation.get(getRelationKey(source, target, 0, relation)); + if (related !== undefined) { + return !!(related & 1); + } + } + if (source.flags & 66846720 || target.flags & 66846720) { + return checkTypeRelatedTo(source, target, relation, undefined); + } + return false; + } + function isIgnoredJsxProperty(source, sourceProp) { + return ts.getObjectFlags(source) & 4096 && !isUnhyphenatedJsxName(sourceProp.escapedName); + } + function getNormalizedType(type, writing) { + return isFreshLiteralType(type) ? type.regularType : + ts.getObjectFlags(type) & 4 && type.node ? createTypeReference(type.target, getTypeArguments(type)) : + type.flags & 33554432 ? writing ? type.typeVariable : type.substitute : + type.flags & 25165824 ? getSimplifiedType(type, writing) : + type; + } + function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) { + var errorInfo; + var relatedInfo; + var maybeKeys; + var sourceStack; + var targetStack; + var maybeCount = 0; + var depth = 0; + var expandingFlags = 0; + var overflow = false; + var overrideNextErrorInfo = 0; + var lastSkippedInfo; + var incompatibleStack = []; + ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking"); + var result = isRelatedTo(source, target, !!errorNode, headMessage); + if (incompatibleStack.length) { + reportIncompatibleStack(); + } + if (overflow) { + var diag = error(errorNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target)); + if (errorOutputContainer) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + else if (errorInfo) { + if (containingMessageChain) { + var chain = containingMessageChain(); + if (chain) { + ts.concatenateDiagnosticMessageChains(chain, errorInfo); + errorInfo = chain; + } + } + var relatedInformation = void 0; + if (headMessage && errorNode && !result && source.symbol) { + var links = getSymbolLinks(source.symbol); + if (links.originatingImport && !ts.isImportCall(links.originatingImport)) { + var helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, undefined); + if (helpfulRetry) { + var diag_1 = ts.createDiagnosticForNode(links.originatingImport, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead); + relatedInformation = ts.append(relatedInformation, diag_1); + } + } + } + var diag = ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation); + if (relatedInfo) { + ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInfo)); + } + if (errorOutputContainer) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + if (!errorOutputContainer || !errorOutputContainer.skipLogging) { + diagnostics.add(diag); + } + } + if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0) { + ts.Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error."); + } + return result !== 0; + function resetErrorInfo(saved) { + errorInfo = saved.errorInfo; + lastSkippedInfo = saved.lastSkippedInfo; + incompatibleStack = saved.incompatibleStack; + overrideNextErrorInfo = saved.overrideNextErrorInfo; + relatedInfo = saved.relatedInfo; + } + function captureErrorCalculationState() { + return { + errorInfo: errorInfo, + lastSkippedInfo: lastSkippedInfo, + incompatibleStack: incompatibleStack.slice(), + overrideNextErrorInfo: overrideNextErrorInfo, + relatedInfo: !relatedInfo ? undefined : relatedInfo.slice() + }; + } + function reportIncompatibleError(message, arg0, arg1, arg2, arg3) { + overrideNextErrorInfo++; + lastSkippedInfo = undefined; + incompatibleStack.push([message, arg0, arg1, arg2, arg3]); + } + function reportIncompatibleStack() { + var stack = incompatibleStack; + incompatibleStack = []; + var info = lastSkippedInfo; + lastSkippedInfo = undefined; + if (stack.length === 1) { + reportError.apply(void 0, stack[0]); + if (info) { + reportRelationError.apply(void 0, __spreadArrays([undefined], info)); + } + return; + } + var path = ""; + var secondaryRootErrors = []; + while (stack.length) { + var _a = stack.pop(), msg = _a[0], args = _a.slice(1); + switch (msg.code) { + case ts.Diagnostics.Types_of_property_0_are_incompatible.code: { + if (path.indexOf("new ") === 0) { + path = "(" + path + ")"; + } + var str = "" + args[0]; + if (path.length === 0) { + path = "" + str; + } + else if (ts.isIdentifierText(str, compilerOptions.target)) { + path = path + "." + str; + } + else if (str[0] === "[" && str[str.length - 1] === "]") { + path = "" + path + str; + } + else { + path = path + "[" + str + "]"; + } + break; + } + case ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code: + case ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code: + case ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: + case ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: { + if (path.length === 0) { + var mappedMsg = msg; + if (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) { + mappedMsg = ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible; + } + else if (msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) { + mappedMsg = ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible; + } + secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]); + } + else { + var prefix = (msg.code === ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code || + msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) + ? "new " + : ""; + var params = (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || + msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) + ? "" + : "..."; + path = "" + prefix + path + "(" + params + ")"; + } + break; + } + default: + return ts.Debug.fail("Unhandled Diagnostic: " + msg.code); + } + } + if (path) { + reportError(path[path.length - 1] === ")" + ? ts.Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types + : ts.Diagnostics.The_types_of_0_are_incompatible_between_these_types, path); + } + else { + secondaryRootErrors.shift(); + } + for (var _i = 0, secondaryRootErrors_1 = secondaryRootErrors; _i < secondaryRootErrors_1.length; _i++) { + var _b = secondaryRootErrors_1[_i], msg = _b[0], args = _b.slice(1); + var originalValue = msg.elidedInCompatabilityPyramid; + msg.elidedInCompatabilityPyramid = false; + reportError.apply(void 0, __spreadArrays([msg], args)); + msg.elidedInCompatabilityPyramid = originalValue; + } + if (info) { + reportRelationError.apply(void 0, __spreadArrays([undefined], info)); + } + } + function reportError(message, arg0, arg1, arg2, arg3) { + ts.Debug.assert(!!errorNode); + if (incompatibleStack.length) + reportIncompatibleStack(); + if (message.elidedInCompatabilityPyramid) + return; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3); + } + function associateRelatedInfo(info) { + ts.Debug.assert(!!errorInfo); + if (!relatedInfo) { + relatedInfo = [info]; + } + else { + relatedInfo.push(info); + } + } + function reportRelationError(message, source, target) { + if (incompatibleStack.length) + reportIncompatibleStack(); + var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1]; + if (target.flags & 262144 && target.immediateBaseConstraint !== undefined && isTypeAssignableTo(source, target.immediateBaseConstraint)) { + reportError(ts.Diagnostics._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, sourceType, targetType, typeToString(target.immediateBaseConstraint)); + } + if (!message) { + if (relation === comparableRelation) { + message = ts.Diagnostics.Type_0_is_not_comparable_to_type_1; + } + else if (sourceType === targetType) { + message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated; + } + else { + message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1; + } + } + reportError(message, sourceType, targetType); + } + function tryElaborateErrorsForPrimitivesAndObjects(source, target) { + var sourceType = symbolValueDeclarationIsContextSensitive(source.symbol) ? typeToString(source, source.symbol.valueDeclaration) : typeToString(source); + var targetType = symbolValueDeclarationIsContextSensitive(target.symbol) ? typeToString(target, target.symbol.valueDeclaration) : typeToString(target); + if ((globalStringType === source && stringType === target) || + (globalNumberType === source && numberType === target) || + (globalBooleanType === source && booleanType === target) || + (getGlobalESSymbolType(false) === source && esSymbolType === target)) { + reportError(ts.Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType); + } + } + function tryElaborateArrayLikeErrors(source, target, reportErrors) { + if (isTupleType(source)) { + if (source.target.readonly && isMutableArrayOrTuple(target)) { + if (reportErrors) { + reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target)); + } + return false; + } + return isTupleType(target) || isArrayType(target); + } + if (isReadonlyArrayType(source) && isMutableArrayOrTuple(target)) { + if (reportErrors) { + reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target)); + } + return false; + } + if (isTupleType(target)) { + return isArrayType(source); + } + return true; + } + function isRelatedTo(originalSource, originalTarget, reportErrors, headMessage, intersectionState) { + if (reportErrors === void 0) { reportErrors = false; } + if (intersectionState === void 0) { intersectionState = 0; } + var source = getNormalizedType(originalSource, false); + var target = getNormalizedType(originalTarget, true); + if (target.flags & 1048576 && source.flags & 524288 && + target.types.length <= 3 && maybeTypeOfKind(target, 98304)) { + var nullStrippedTarget = extractTypesOfKind(target, ~98304); + if (!(nullStrippedTarget.flags & (1048576 | 131072))) { + target = nullStrippedTarget; + } + } + if (source === target) + return -1; + if (relation === identityRelation) { + return isIdenticalTo(source, target); + } + if (relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) || + isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) + return -1; + var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096); + var isPerformingExcessPropertyChecks = !(intersectionState & 2) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 32768); + if (isPerformingExcessPropertyChecks) { + if (hasExcessProperties(source, target, reportErrors)) { + if (reportErrors) { + reportRelationError(headMessage, source, target); + } + return 0; + } + } + var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2) && + source.flags & (131068 | 524288 | 2097152) && source !== globalObjectType && + target.flags & (524288 | 2097152) && isWeakType(target) && + (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source)); + if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) { + if (reportErrors) { + var calls = getSignaturesOfType(source, 0); + var constructs = getSignaturesOfType(source, 1); + if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, false) || + constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, false)) { + reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, typeToString(source), typeToString(target)); + } + else { + reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, typeToString(source), typeToString(target)); + } + } + return 0; + } + var result = 0; + var saveErrorInfo = captureErrorCalculationState(); + if (source.flags & 1048576) { + result = relation === comparableRelation ? + someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068), intersectionState) : + eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068)); + } + else { + if (target.flags & 1048576) { + result = typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068) && !(target.flags & 131068)); + } + else if (target.flags & 2097152) { + result = typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2); + if (result && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks)) { + if (!propertiesRelatedTo(source, target, reportErrors, undefined, 0)) { + return 0; + } + } + } + else if (source.flags & 2097152) { + result = someTypeRelatedToType(source, target, false, 1); + } + if (!result && (source.flags & 66846720 || target.flags & 66846720)) { + if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) { + resetErrorInfo(saveErrorInfo); + } + } + } + if (!result && source.flags & (2097152 | 262144)) { + var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 ? source.types : [source], !!(target.flags & 1048576)); + if (constraint && (source.flags & 2097152 || target.flags & 1048576)) { + if (everyType(constraint, function (c) { return c !== source; })) { + if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) { + resetErrorInfo(saveErrorInfo); + } + } + } + } + if (!result && reportErrors) { + source = originalSource.aliasSymbol ? originalSource : source; + target = originalTarget.aliasSymbol ? originalTarget : target; + var maybeSuppress = overrideNextErrorInfo > 0; + if (maybeSuppress) { + overrideNextErrorInfo--; + } + if (source.flags & 524288 && target.flags & 524288) { + var currentError = errorInfo; + tryElaborateArrayLikeErrors(source, target, reportErrors); + if (errorInfo !== currentError) { + maybeSuppress = !!errorInfo; + } + } + if (source.flags & 524288 && target.flags & 131068) { + tryElaborateErrorsForPrimitivesAndObjects(source, target); + } + else if (source.symbol && source.flags & 524288 && globalObjectType === source) { + reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead); + } + else if (isComparingJsxAttributes && target.flags & 2097152) { + var targetTypes = target.types; + var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode); + var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode); + if (intrinsicAttributes !== errorType && intrinsicClassAttributes !== errorType && + (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) { + return result; + } + } + if (!headMessage && maybeSuppress) { + lastSkippedInfo = [source, target]; + return result; + } + reportRelationError(headMessage, source, target); + } + return result; + } + function isIdenticalTo(source, target) { + var result; + var flags = source.flags & target.flags; + if (flags & 524288 || flags & 8388608 || flags & 16777216 || flags & 4194304 || flags & 33554432) { + return recursiveTypeRelatedTo(source, target, false, 0); + } + if (flags & (1048576 | 2097152)) { + if (result = eachTypeRelatedToSomeType(source, target)) { + if (result &= eachTypeRelatedToSomeType(target, source)) { + return result; + } + } + } + return 0; + } + function getTypeOfPropertyInTypes(types, name) { + var appendPropType = function (propTypes, type) { + type = getApparentType(type); + var prop = type.flags & 3145728 ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name); + var propType = prop && getTypeOfSymbol(prop) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || undefinedType; + return ts.append(propTypes, propType); + }; + return getUnionType(ts.reduceLeft(types, appendPropType, undefined) || ts.emptyArray); + } + function hasExcessProperties(source, target, reportErrors) { + if (!isExcessPropertyCheckTarget(target) || !noImplicitAny && ts.getObjectFlags(target) & 16384) { + return false; + } + var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096); + if ((relation === assignableRelation || relation === comparableRelation) && + (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) { + return false; + } + var reducedTarget = target; + var checkTypes; + if (target.flags & 1048576) { + reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target); + checkTypes = reducedTarget.flags & 1048576 ? reducedTarget.types : [reducedTarget]; + } + var _loop_11 = function (prop) { + if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) { + if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) { + if (reportErrors) { + var errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget); + if (!errorNode) + return { value: ts.Debug.fail() }; + if (ts.isJsxAttributes(errorNode) || ts.isJsxOpeningLikeElement(errorNode) || ts.isJsxOpeningLikeElement(errorNode.parent)) { + if (prop.valueDeclaration && ts.isJsxAttribute(prop.valueDeclaration) && ts.getSourceFileOfNode(errorNode) === ts.getSourceFileOfNode(prop.valueDeclaration.name)) { + errorNode = prop.valueDeclaration.name; + } + reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(prop), typeToString(errorTarget)); + } + else { + var objectLiteralDeclaration_1 = source.symbol && ts.firstOrUndefined(source.symbol.declarations); + var suggestion = void 0; + if (prop.valueDeclaration && ts.findAncestor(prop.valueDeclaration, function (d) { return d === objectLiteralDeclaration_1; }) && ts.getSourceFileOfNode(objectLiteralDeclaration_1) === ts.getSourceFileOfNode(errorNode)) { + var propDeclaration = prop.valueDeclaration; + ts.Debug.assertNode(propDeclaration, ts.isObjectLiteralElementLike); + errorNode = propDeclaration; + var name = propDeclaration.name; + if (ts.isIdentifier(name)) { + suggestion = getSuggestionForNonexistentProperty(name, errorTarget); + } + } + if (suggestion !== undefined) { + reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2, symbolToString(prop), typeToString(errorTarget), suggestion); + } + else { + reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(errorTarget)); + } + } + } + return { value: true }; + } + if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), reportErrors)) { + if (reportErrors) { + reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop)); + } + return { value: true }; + } + } + }; + for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) { + var prop = _a[_i]; + var state_4 = _loop_11(prop); + if (typeof state_4 === "object") + return state_4.value; + } + return false; + } + function shouldCheckAsExcessProperty(prop, container) { + return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration; + } + function eachTypeRelatedToSomeType(source, target) { + var result = -1; + var sourceTypes = source.types; + for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) { + var sourceType = sourceTypes_1[_i]; + var related = typeRelatedToSomeType(sourceType, target, false); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function typeRelatedToSomeType(source, target, reportErrors) { + var targetTypes = target.types; + if (target.flags & 1048576 && containsType(targetTypes, source)) { + return -1; + } + for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) { + var type = targetTypes_1[_i]; + var related = isRelatedTo(source, type, false); + if (related) { + return related; + } + } + if (reportErrors) { + var bestMatchingType = getBestMatchingType(source, target, isRelatedTo); + isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], true); + } + return 0; + } + function typeRelatedToEachType(source, target, reportErrors, intersectionState) { + var result = -1; + var targetTypes = target.types; + for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) { + var targetType = targetTypes_2[_i]; + var related = isRelatedTo(source, targetType, reportErrors, undefined, intersectionState); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function someTypeRelatedToType(source, target, reportErrors, intersectionState) { + var sourceTypes = source.types; + if (source.flags & 1048576 && containsType(sourceTypes, target)) { + return -1; + } + var len = sourceTypes.length; + for (var i = 0; i < len; i++) { + var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1, undefined, intersectionState); + if (related) { + return related; + } + } + return 0; + } + function eachTypeRelatedToType(source, target, reportErrors) { + var result = -1; + var sourceTypes = source.types; + for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) { + var sourceType = sourceTypes_2[_i]; + var related = isRelatedTo(sourceType, target, reportErrors); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function typeArgumentsRelatedTo(sources, targets, variances, reportErrors, intersectionState) { + if (sources === void 0) { sources = ts.emptyArray; } + if (targets === void 0) { targets = ts.emptyArray; } + if (variances === void 0) { variances = ts.emptyArray; } + if (sources.length !== targets.length && relation === identityRelation) { + return 0; + } + var length = sources.length <= targets.length ? sources.length : targets.length; + var result = -1; + for (var i = 0; i < length; i++) { + var varianceFlags = i < variances.length ? variances[i] : 1; + var variance = varianceFlags & 7; + if (variance !== 4) { + var s = sources[i]; + var t = targets[i]; + var related = -1; + if (varianceFlags & 8) { + related = relation === identityRelation ? isRelatedTo(s, t, false) : compareTypesIdentical(s, t); + } + else if (variance === 1) { + related = isRelatedTo(s, t, reportErrors, undefined, intersectionState); + } + else if (variance === 2) { + related = isRelatedTo(t, s, reportErrors, undefined, intersectionState); + } + else if (variance === 3) { + related = isRelatedTo(t, s, false); + if (!related) { + related = isRelatedTo(s, t, reportErrors, undefined, intersectionState); + } + } + else { + related = isRelatedTo(s, t, reportErrors, undefined, intersectionState); + if (related) { + related &= isRelatedTo(t, s, reportErrors, undefined, intersectionState); + } + } + if (!related) { + return 0; + } + result &= related; + } + } + return result; + } + function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState) { + if (overflow) { + return 0; + } + var id = getRelationKey(source, target, intersectionState, relation); + var entry = relation.get(id); + if (entry !== undefined) { + if (reportErrors && entry & 2 && !(entry & 4)) { + } + else { + if (outofbandVarianceMarkerHandler) { + var saved = entry & 24; + if (saved & 8) { + instantiateType(source, reportUnmeasurableMarkers); + } + if (saved & 16) { + instantiateType(source, reportUnreliableMarkers); + } + } + return entry & 1 ? -1 : 0; + } + } + if (!maybeKeys) { + maybeKeys = []; + sourceStack = []; + targetStack = []; + } + else { + for (var i = 0; i < maybeCount; i++) { + if (id === maybeKeys[i]) { + return 1; + } + } + if (depth === 100) { + overflow = true; + return 0; + } + } + var maybeStart = maybeCount; + maybeKeys[maybeCount] = id; + maybeCount++; + sourceStack[depth] = source; + targetStack[depth] = target; + depth++; + var saveExpandingFlags = expandingFlags; + if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, depth)) + expandingFlags |= 1; + if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, depth)) + expandingFlags |= 2; + var originalHandler; + var propagatingVarianceFlags = 0; + if (outofbandVarianceMarkerHandler) { + originalHandler = outofbandVarianceMarkerHandler; + outofbandVarianceMarkerHandler = function (onlyUnreliable) { + propagatingVarianceFlags |= onlyUnreliable ? 16 : 8; + return originalHandler(onlyUnreliable); + }; + } + var result = expandingFlags !== 3 ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 1; + if (outofbandVarianceMarkerHandler) { + outofbandVarianceMarkerHandler = originalHandler; + } + expandingFlags = saveExpandingFlags; + depth--; + if (result) { + if (result === -1 || depth === 0) { + for (var i = maybeStart; i < maybeCount; i++) { + relation.set(maybeKeys[i], 1 | propagatingVarianceFlags); + } + maybeCount = maybeStart; + } + } + else { + relation.set(id, (reportErrors ? 4 : 0) | 2 | propagatingVarianceFlags); + maybeCount = maybeStart; + } + return result; + } + function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) { + var flags = source.flags & target.flags; + if (relation === identityRelation && !(flags & 524288)) { + if (flags & 4194304) { + return isRelatedTo(source.type, target.type, false); + } + var result_3 = 0; + if (flags & 8388608) { + if (result_3 = isRelatedTo(source.objectType, target.objectType, false)) { + if (result_3 &= isRelatedTo(source.indexType, target.indexType, false)) { + return result_3; + } + } + } + if (flags & 16777216) { + if (source.root.isDistributive === target.root.isDistributive) { + if (result_3 = isRelatedTo(source.checkType, target.checkType, false)) { + if (result_3 &= isRelatedTo(source.extendsType, target.extendsType, false)) { + if (result_3 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), false)) { + if (result_3 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), false)) { + return result_3; + } + } + } + } + } + } + if (flags & 33554432) { + return isRelatedTo(source.substitute, target.substitute, false); + } + return 0; + } + var result; + var originalErrorInfo; + var varianceCheckFailed = false; + var saveErrorInfo = captureErrorCalculationState(); + if (source.flags & (524288 | 16777216) && source.aliasSymbol && + source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol && + !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) { + var variances = getAliasVariances(source.aliasSymbol); + if (variances === ts.emptyArray) { + return 1; + } + var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState); + if (varianceResult !== undefined) { + return varianceResult; + } + } + if (target.flags & 262144) { + if (ts.getObjectFlags(source) & 32 && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source))) { + if (!(getMappedTypeModifiers(source) & 4)) { + var templateType = getTemplateTypeFromMappedType(source); + var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source)); + if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) { + return result; + } + } + } + } + else if (target.flags & 4194304) { + if (source.flags & 4194304) { + if (result = isRelatedTo(target.type, source.type, false)) { + return result; + } + } + var constraint = getSimplifiedTypeOrConstraint(target.type); + if (constraint) { + if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), reportErrors) === -1) { + return -1; + } + } + } + else if (target.flags & 8388608) { + if (relation !== identityRelation) { + var objectType = target.objectType; + var indexType = target.indexType; + var baseObjectType = getBaseConstraintOfType(objectType) || objectType; + var baseIndexType = getBaseConstraintOfType(indexType) || indexType; + if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) { + var accessFlags = 2 | (baseObjectType !== objectType ? 1 : 0); + var constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, undefined, accessFlags); + if (constraint && (result = isRelatedTo(source, constraint, reportErrors))) { + return result; + } + } + } + } + else if (isGenericMappedType(target)) { + var template = getTemplateTypeFromMappedType(target); + var modifiers = getMappedTypeModifiers(target); + if (!(modifiers & 8)) { + if (template.flags & 8388608 && template.objectType === source && + template.indexType === getTypeParameterFromMappedType(target)) { + return -1; + } + if (!isGenericMappedType(source)) { + var targetConstraint = getConstraintTypeFromMappedType(target); + var sourceKeys = getIndexType(source, undefined, true); + var includeOptional = modifiers & 4; + var filteredByApplicability = includeOptional ? intersectTypes(targetConstraint, sourceKeys) : undefined; + if (includeOptional + ? !(filteredByApplicability.flags & 131072) + : isRelatedTo(targetConstraint, sourceKeys)) { + var typeParameter = getTypeParameterFromMappedType(target); + var indexingType = filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter; + var indexedAccessType = getIndexedAccessType(source, indexingType); + var templateType = getTemplateTypeFromMappedType(target); + if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) { + return result; + } + } + originalErrorInfo = errorInfo; + resetErrorInfo(saveErrorInfo); + } + } + } + if (source.flags & 8650752) { + if (source.flags & 8388608 && target.flags & 8388608) { + if (result = isRelatedTo(source.objectType, target.objectType, reportErrors)) { + result &= isRelatedTo(source.indexType, target.indexType, reportErrors); + } + if (result) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + else { + var constraint = getConstraintOfType(source); + if (!constraint || (source.flags & 262144 && constraint.flags & 1)) { + if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + else if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) { + resetErrorInfo(saveErrorInfo); + return result; + } + else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors, undefined, intersectionState)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + } + else if (source.flags & 4194304) { + if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + else if (source.flags & 16777216) { + if (target.flags & 16777216) { + var sourceParams = source.root.inferTypeParameters; + var sourceExtends = source.extendsType; + var mapper = void 0; + if (sourceParams) { + var ctx = createInferenceContext(sourceParams, undefined, 0, isRelatedTo); + inferTypes(ctx.inferences, target.extendsType, sourceExtends, 128 | 256); + sourceExtends = instantiateType(sourceExtends, ctx.mapper); + mapper = ctx.mapper; + } + if (isTypeIdenticalTo(sourceExtends, target.extendsType) && + (isRelatedTo(source.checkType, target.checkType) || isRelatedTo(target.checkType, source.checkType))) { + if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), reportErrors)) { + result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), reportErrors); + } + if (result) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + } + else { + var distributiveConstraint = getConstraintOfDistributiveConditionalType(source); + if (distributiveConstraint) { + if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + var defaultConstraint = getDefaultConstraintOfConditionalType(source); + if (defaultConstraint) { + if (result = isRelatedTo(defaultConstraint, target, reportErrors)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + } + } + else { + if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target) && isEmptyObjectType(source)) { + return -1; + } + if (isGenericMappedType(target)) { + if (isGenericMappedType(source)) { + if (result = mappedTypeRelatedTo(source, target, reportErrors)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + return 0; + } + var sourceIsPrimitive = !!(source.flags & 131068); + if (relation !== identityRelation) { + source = getApparentType(source); + } + else if (isGenericMappedType(source)) { + return 0; + } + if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && source.target === target.target && + !(ts.getObjectFlags(source) & 8192 || ts.getObjectFlags(target) & 8192)) { + var variances = getVariances(source.target); + if (variances === ts.emptyArray) { + return 1; + } + var varianceResult = relateVariances(getTypeArguments(source), getTypeArguments(target), variances, intersectionState); + if (varianceResult !== undefined) { + return varianceResult; + } + } + else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) { + if (relation !== identityRelation) { + return isRelatedTo(getIndexTypeOfType(source, 1) || anyType, getIndexTypeOfType(target, 1) || anyType, reportErrors); + } + else { + return 0; + } + } + else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target) && ts.getObjectFlags(target) & 32768 && !isEmptyObjectType(source)) { + return 0; + } + if (source.flags & (524288 | 2097152) && target.flags & 524288) { + var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive; + result = propertiesRelatedTo(source, target, reportStructuralErrors, undefined, intersectionState); + if (result) { + result &= signaturesRelatedTo(source, target, 0, reportStructuralErrors); + if (result) { + result &= signaturesRelatedTo(source, target, 1, reportStructuralErrors); + if (result) { + result &= indexTypesRelatedTo(source, target, 0, sourceIsPrimitive, reportStructuralErrors, intersectionState); + if (result) { + result &= indexTypesRelatedTo(source, target, 1, sourceIsPrimitive, reportStructuralErrors, intersectionState); + } + } + } + } + if (varianceCheckFailed && result) { + errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo; + } + else if (result) { + return result; + } + } + if (source.flags & (524288 | 2097152) && target.flags & 1048576) { + var objectOnlyTarget = extractTypesOfKind(target, 524288 | 2097152 | 33554432); + if (objectOnlyTarget.flags & 1048576) { + var result_4 = typeRelatedToDiscriminatedType(source, objectOnlyTarget); + if (result_4) { + return result_4; + } + } + } + } + return 0; + function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState) { + if (result = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState)) { + return result; + } + if (ts.some(variances, function (v) { return !!(v & 24); })) { + originalErrorInfo = undefined; + resetErrorInfo(saveErrorInfo); + return undefined; + } + var allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances); + varianceCheckFailed = !allowStructuralFallback; + if (variances !== ts.emptyArray && !allowStructuralFallback) { + if (varianceCheckFailed && !(reportErrors && ts.some(variances, function (v) { return (v & 7) === 0; }))) { + return 0; + } + originalErrorInfo = errorInfo; + resetErrorInfo(saveErrorInfo); + } + } + } + function reportUnmeasurableMarkers(p) { + if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) { + outofbandVarianceMarkerHandler(false); + } + return p; + } + function reportUnreliableMarkers(p) { + if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) { + outofbandVarianceMarkerHandler(true); + } + return p; + } + function mappedTypeRelatedTo(source, target, reportErrors) { + var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) : + getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target)); + if (modifiersRelated) { + var result_5; + var targetConstraint = getConstraintTypeFromMappedType(target); + var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers); + if (result_5 = isRelatedTo(targetConstraint, sourceConstraint, reportErrors)) { + var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]); + return result_5 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors); + } + } + return 0; + } + function typeRelatedToDiscriminatedType(source, target) { + var sourceProperties = getPropertiesOfType(source); + var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target); + if (!sourcePropertiesFiltered) + return 0; + var numCombinations = 1; + for (var _i = 0, sourcePropertiesFiltered_1 = sourcePropertiesFiltered; _i < sourcePropertiesFiltered_1.length; _i++) { + var sourceProperty = sourcePropertiesFiltered_1[_i]; + numCombinations *= countTypes(getTypeOfSymbol(sourceProperty)); + if (numCombinations > 25) { + return 0; + } + } + var sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length); + var excludedProperties = ts.createUnderscoreEscapedMap(); + for (var i = 0; i < sourcePropertiesFiltered.length; i++) { + var sourceProperty = sourcePropertiesFiltered[i]; + var sourcePropertyType = getTypeOfSymbol(sourceProperty); + sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576 + ? sourcePropertyType.types + : [sourcePropertyType]; + excludedProperties.set(sourceProperty.escapedName, true); + } + var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes); + var matchingTypes = []; + var _loop_12 = function (combination) { + var hasMatch = false; + outer: for (var _i = 0, _a = target.types; _i < _a.length; _i++) { + var type = _a[_i]; + var _loop_13 = function (i) { + var sourceProperty = sourcePropertiesFiltered[i]; + var targetProperty = getPropertyOfType(type, sourceProperty.escapedName); + if (!targetProperty) + return "continue-outer"; + if (sourceProperty === targetProperty) + return "continue"; + var related = propertyRelatedTo(source, target, sourceProperty, targetProperty, function (_) { return combination[i]; }, false, 0); + if (!related) { + return "continue-outer"; + } + }; + for (var i = 0; i < sourcePropertiesFiltered.length; i++) { + var state_6 = _loop_13(i); + switch (state_6) { + case "continue-outer": continue outer; + } + } + ts.pushIfUnique(matchingTypes, type, ts.equateValues); + hasMatch = true; + } + if (!hasMatch) { + return { value: 0 }; + } + }; + for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) { + var combination = discriminantCombinations_1[_a]; + var state_5 = _loop_12(combination); + if (typeof state_5 === "object") + return state_5.value; + } + var result = -1; + for (var _b = 0, matchingTypes_1 = matchingTypes; _b < matchingTypes_1.length; _b++) { + var type = matchingTypes_1[_b]; + result &= propertiesRelatedTo(source, type, false, excludedProperties, 0); + if (result) { + result &= signaturesRelatedTo(source, type, 0, false); + if (result) { + result &= signaturesRelatedTo(source, type, 1, false); + if (result) { + result &= indexTypesRelatedTo(source, type, 0, false, false, 0); + if (result) { + result &= indexTypesRelatedTo(source, type, 1, false, false, 0); + } + } + } + } + if (!result) { + return result; + } + } + return result; + } + function excludeProperties(properties, excludedProperties) { + if (!excludedProperties || properties.length === 0) + return properties; + var result; + for (var i = 0; i < properties.length; i++) { + if (!excludedProperties.has(properties[i].escapedName)) { + if (result) { + result.push(properties[i]); + } + } + else if (!result) { + result = properties.slice(0, i); + } + } + return result || properties; + } + function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState) { + var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48); + var source = getTypeOfSourceProperty(sourceProp); + if (ts.getCheckFlags(targetProp) & 65536 && !getSymbolLinks(targetProp).type) { + var links = getSymbolLinks(targetProp); + ts.Debug.assertDefined(links.deferralParent); + ts.Debug.assertDefined(links.deferralConstituents); + var unionParent = !!(links.deferralParent.flags & 1048576); + var result_6 = unionParent ? 0 : -1; + var targetTypes = links.deferralConstituents; + for (var _i = 0, targetTypes_3 = targetTypes; _i < targetTypes_3.length; _i++) { + var targetType = targetTypes_3[_i]; + var related = isRelatedTo(source, targetType, false, undefined, unionParent ? 0 : 2); + if (!unionParent) { + if (!related) { + return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors); + } + result_6 &= related; + } + else { + if (related) { + return related; + } + } + } + if (unionParent && !result_6 && targetIsOptional) { + result_6 = isRelatedTo(source, undefinedType); + } + if (unionParent && !result_6 && reportErrors) { + return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors); + } + return result_6; + } + else { + return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors, undefined, intersectionState); + } + } + function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState) { + var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp); + var targetPropFlags = ts.getDeclarationModifierFlagsFromSymbol(targetProp); + if (sourcePropFlags & 8 || targetPropFlags & 8) { + var hasDifferingDeclarations = sourceProp.valueDeclaration !== targetProp.valueDeclaration; + if (ts.getCheckFlags(sourceProp) & 1024 && hasDifferingDeclarations) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1, symbolToString(sourceProp), typeToString(source)); + } + return 0; + } + if (hasDifferingDeclarations) { + if (reportErrors) { + if (sourcePropFlags & 8 && targetPropFlags & 8) { + reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp)); + } + else { + reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 ? source : target), typeToString(sourcePropFlags & 8 ? target : source)); + } + } + return 0; + } + } + else if (targetPropFlags & 16) { + if (!isValidOverrideOf(sourceProp, targetProp)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source), typeToString(getDeclaringClass(targetProp) || target)); + } + return 0; + } + } + else if (sourcePropFlags & 16) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0; + } + var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState); + if (!related) { + if (reportErrors) { + reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp)); + } + return 0; + } + if (relation !== comparableRelation && sourceProp.flags & 16777216 && !(targetProp.flags & 16777216)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0; + } + return related; + } + function reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties) { + var shouldSkipElaboration = false; + if (unmatchedProperty.valueDeclaration + && ts.isNamedDeclaration(unmatchedProperty.valueDeclaration) + && ts.isPrivateIdentifier(unmatchedProperty.valueDeclaration.name) + && source.symbol + && source.symbol.flags & 32) { + var privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText; + var symbolTableKey = ts.getSymbolNameForPrivateIdentifier(source.symbol, privateIdentifierDescription); + if (symbolTableKey && getPropertyOfType(source, symbolTableKey)) { + var sourceName = ts.getDeclarationName(source.symbol.valueDeclaration); + var targetName = ts.getDeclarationName(target.symbol.valueDeclaration); + reportError(ts.Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2, diagnosticName(privateIdentifierDescription), diagnosticName(sourceName.escapedText === "" ? anon : sourceName), diagnosticName(targetName.escapedText === "" ? anon : targetName)); + return; + } + } + var props = ts.arrayFrom(getUnmatchedProperties(source, target, requireOptionalProperties, false)); + if (!headMessage || (headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_interface_1.code && + headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code)) { + shouldSkipElaboration = true; + } + if (props.length === 1) { + var propName = symbolToString(unmatchedProperty); + reportError.apply(void 0, __spreadArrays([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target))); + if (ts.length(unmatchedProperty.declarations)) { + associateRelatedInfo(ts.createDiagnosticForNode(unmatchedProperty.declarations[0], ts.Diagnostics._0_is_declared_here, propName)); + } + if (shouldSkipElaboration && errorInfo) { + overrideNextErrorInfo++; + } + } + else if (tryElaborateArrayLikeErrors(source, target, false)) { + if (props.length > 5) { + reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source), typeToString(target), ts.map(props.slice(0, 4), function (p) { return symbolToString(p); }).join(", "), props.length - 4); + } + else { + reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source), typeToString(target), ts.map(props, function (p) { return symbolToString(p); }).join(", ")); + } + if (shouldSkipElaboration && errorInfo) { + overrideNextErrorInfo++; + } + } + } + function propertiesRelatedTo(source, target, reportErrors, excludedProperties, intersectionState) { + if (relation === identityRelation) { + return propertiesIdenticalTo(source, target, excludedProperties); + } + var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source); + var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, false); + if (unmatchedProperty) { + if (reportErrors) { + reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties); + } + return 0; + } + if (isObjectLiteralType(target)) { + for (var _i = 0, _a = excludeProperties(getPropertiesOfType(source), excludedProperties); _i < _a.length; _i++) { + var sourceProp = _a[_i]; + if (!getPropertyOfObjectType(target, sourceProp.escapedName)) { + var sourceType = getTypeOfSymbol(sourceProp); + if (!(sourceType === undefinedType || sourceType === undefinedWideningType || sourceType === optionalType)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target)); + } + return 0; + } + } + } + } + var result = -1; + if (isTupleType(target)) { + var targetRestType = getRestTypeOfTupleType(target); + if (targetRestType) { + if (!isTupleType(source)) { + return 0; + } + var sourceRestType = getRestTypeOfTupleType(source); + if (sourceRestType && !isRelatedTo(sourceRestType, targetRestType, reportErrors)) { + if (reportErrors) { + reportError(ts.Diagnostics.Rest_signatures_are_incompatible); + } + return 0; + } + var targetCount = getTypeReferenceArity(target) - 1; + var sourceCount = getTypeReferenceArity(source) - (sourceRestType ? 1 : 0); + var sourceTypeArguments = getTypeArguments(source); + for (var i = targetCount; i < sourceCount; i++) { + var related = isRelatedTo(sourceTypeArguments[i], targetRestType, reportErrors); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_incompatible_with_rest_element_type, "" + i); + } + return 0; + } + result &= related; + } + } + } + var properties = getPropertiesOfType(target); + var numericNamesOnly = isTupleType(source) && isTupleType(target); + for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) { + var targetProp = _c[_b]; + var name = targetProp.escapedName; + if (!(targetProp.flags & 4194304) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) { + var sourceProp = getPropertyOfType(source, name); + if (sourceProp && sourceProp !== targetProp) { + var related = propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSymbol, reportErrors, intersectionState); + if (!related) { + return 0; + } + result &= related; + } + } + } + return result; + } + function propertiesIdenticalTo(source, target, excludedProperties) { + if (!(source.flags & 524288 && target.flags & 524288)) { + return 0; + } + var sourceProperties = excludeProperties(getPropertiesOfObjectType(source), excludedProperties); + var targetProperties = excludeProperties(getPropertiesOfObjectType(target), excludedProperties); + if (sourceProperties.length !== targetProperties.length) { + return 0; + } + var result = -1; + for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) { + var sourceProp = sourceProperties_1[_i]; + var targetProp = getPropertyOfObjectType(target, sourceProp.escapedName); + if (!targetProp) { + return 0; + } + var related = compareProperties(sourceProp, targetProp, isRelatedTo); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function signaturesRelatedTo(source, target, kind, reportErrors) { + if (relation === identityRelation) { + return signaturesIdenticalTo(source, target, kind); + } + if (target === anyFunctionType || source === anyFunctionType) { + return -1; + } + var sourceIsJSConstructor = source.symbol && isJSConstructor(source.symbol.valueDeclaration); + var targetIsJSConstructor = target.symbol && isJSConstructor(target.symbol.valueDeclaration); + var sourceSignatures = getSignaturesOfType(source, (sourceIsJSConstructor && kind === 1) ? + 0 : kind); + var targetSignatures = getSignaturesOfType(target, (targetIsJSConstructor && kind === 1) ? + 0 : kind); + if (kind === 1 && sourceSignatures.length && targetSignatures.length) { + if (ts.isAbstractConstructorType(source) && !ts.isAbstractConstructorType(target)) { + if (reportErrors) { + reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type); + } + return 0; + } + if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors)) { + return 0; + } + } + var result = -1; + var saveErrorInfo = captureErrorCalculationState(); + var incompatibleReporter = kind === 1 ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn; + if (ts.getObjectFlags(source) & 64 && ts.getObjectFlags(target) & 64 && source.symbol === target.symbol) { + for (var i = 0; i < targetSignatures.length; i++) { + var related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i])); + if (!related) { + return 0; + } + result &= related; + } + } + else if (sourceSignatures.length === 1 && targetSignatures.length === 1) { + var eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks; + result = signatureRelatedTo(sourceSignatures[0], targetSignatures[0], eraseGenerics, reportErrors, incompatibleReporter(sourceSignatures[0], targetSignatures[0])); + } + else { + outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) { + var t = targetSignatures_1[_i]; + var shouldElaborateErrors = reportErrors; + for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) { + var s = sourceSignatures_1[_a]; + var related = signatureRelatedTo(s, t, true, shouldElaborateErrors, incompatibleReporter(s, t)); + if (related) { + result &= related; + resetErrorInfo(saveErrorInfo); + continue outer; + } + shouldElaborateErrors = false; + } + if (shouldElaborateErrors) { + reportError(ts.Diagnostics.Type_0_provides_no_match_for_the_signature_1, typeToString(source), signatureToString(t, undefined, undefined, kind)); + } + return 0; + } + } + return result; + } + function reportIncompatibleCallSignatureReturn(siga, sigb) { + if (siga.parameters.length === 0 && sigb.parameters.length === 0) { + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); }; + } + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); }; + } + function reportIncompatibleConstructSignatureReturn(siga, sigb) { + if (siga.parameters.length === 0 && sigb.parameters.length === 0) { + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); }; + } + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); }; + } + function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) { + return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 : 0, reportErrors, reportError, incompatibleReporter, isRelatedTo, reportUnreliableMarkers); + } + function signaturesIdenticalTo(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + if (sourceSignatures.length !== targetSignatures.length) { + return 0; + } + var result = -1; + for (var i = 0; i < sourceSignatures.length; i++) { + var related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], false, false, false, isRelatedTo); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function eachPropertyRelatedTo(source, target, kind, reportErrors) { + var result = -1; + var props = source.flags & 2097152 ? getPropertiesOfUnionOrIntersectionType(source) : getPropertiesOfObjectType(source); + for (var _i = 0, props_2 = props; _i < props_2.length; _i++) { + var prop = props_2[_i]; + if (isIgnoredJsxProperty(source, prop)) { + continue; + } + var nameType = getSymbolLinks(prop).nameType; + if (nameType && nameType.flags & 8192) { + continue; + } + if (kind === 0 || isNumericLiteralName(prop.escapedName)) { + var related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop)); + } + return 0; + } + result &= related; + } + } + return result; + } + function indexTypeRelatedTo(sourceType, targetType, reportErrors) { + var related = isRelatedTo(sourceType, targetType, reportErrors); + if (!related && reportErrors) { + reportError(ts.Diagnostics.Index_signatures_are_incompatible); + } + return related; + } + function indexTypesRelatedTo(source, target, kind, sourceIsPrimitive, reportErrors, intersectionState) { + if (relation === identityRelation) { + return indexTypesIdenticalTo(source, target, kind); + } + var targetType = getIndexTypeOfType(target, kind); + if (!targetType || targetType.flags & 1 && !sourceIsPrimitive) { + return -1; + } + if (isGenericMappedType(source)) { + return kind === 0 ? isRelatedTo(getTemplateTypeFromMappedType(source), targetType, reportErrors) : 0; + } + var indexType = getIndexTypeOfType(source, kind) || kind === 1 && getIndexTypeOfType(source, 0); + if (indexType) { + return indexTypeRelatedTo(indexType, targetType, reportErrors); + } + if (!(intersectionState & 1) && isObjectTypeWithInferableIndex(source)) { + var related = eachPropertyRelatedTo(source, targetType, kind, reportErrors); + if (related && kind === 0) { + var numberIndexType = getIndexTypeOfType(source, 1); + if (numberIndexType) { + related &= indexTypeRelatedTo(numberIndexType, targetType, reportErrors); + } + } + return related; + } + if (reportErrors) { + reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source)); + } + return 0; + } + function indexTypesIdenticalTo(source, target, indexKind) { + var targetInfo = getIndexInfoOfType(target, indexKind); + var sourceInfo = getIndexInfoOfType(source, indexKind); + if (!sourceInfo && !targetInfo) { + return -1; + } + if (sourceInfo && targetInfo && sourceInfo.isReadonly === targetInfo.isReadonly) { + return isRelatedTo(sourceInfo.type, targetInfo.type); + } + return 0; + } + function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) { + if (!sourceSignature.declaration || !targetSignature.declaration) { + return true; + } + var sourceAccessibility = ts.getSelectedModifierFlags(sourceSignature.declaration, 24); + var targetAccessibility = ts.getSelectedModifierFlags(targetSignature.declaration, 24); + if (targetAccessibility === 8) { + return true; + } + if (targetAccessibility === 16 && sourceAccessibility !== 8) { + return true; + } + if (targetAccessibility !== 16 && !sourceAccessibility) { + return true; + } + if (reportErrors) { + reportError(ts.Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility)); + } + return false; + } + } + function getBestMatchingType(source, target, isRelatedTo) { + if (isRelatedTo === void 0) { isRelatedTo = compareTypesAssignable; } + return findMatchingDiscriminantType(source, target, isRelatedTo) || + findMatchingTypeReferenceOrTypeAliasReference(source, target) || + findBestTypeForObjectLiteral(source, target) || + findBestTypeForInvokable(source, target) || + findMostOverlappyType(source, target); + } + function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue) { + var discriminable = target.types.map(function (_) { return undefined; }); + for (var _i = 0, discriminators_1 = discriminators; _i < discriminators_1.length; _i++) { + var _a = discriminators_1[_i], getDiscriminatingType = _a[0], propertyName = _a[1]; + var i = 0; + for (var _b = 0, _c = target.types; _b < _c.length; _b++) { + var type = _c[_b]; + var targetType = getTypeOfPropertyOfType(type, propertyName); + if (targetType && related(getDiscriminatingType(), targetType)) { + discriminable[i] = discriminable[i] === undefined ? true : discriminable[i]; + } + else { + discriminable[i] = false; + } + i++; + } + } + var match = discriminable.indexOf(true); + return match === -1 || discriminable.indexOf(true, match + 1) !== -1 ? defaultValue : target.types[match]; + } + function isWeakType(type) { + if (type.flags & 524288) { + var resolved = resolveStructuredTypeMembers(type); + return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && + !resolved.stringIndexInfo && !resolved.numberIndexInfo && + resolved.properties.length > 0 && + ts.every(resolved.properties, function (p) { return !!(p.flags & 16777216); }); + } + if (type.flags & 2097152) { + return ts.every(type.types, isWeakType); + } + return false; + } + function hasCommonProperties(source, target, isComparingJsxAttributes) { + for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) { + var prop = _a[_i]; + if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) { + return true; + } + } + return false; + } + function getMarkerTypeReference(type, source, target) { + var result = createTypeReference(type, ts.map(type.typeParameters, function (t) { return t === source ? target : t; })); + result.objectFlags |= 8192; + return result; + } + function getAliasVariances(symbol) { + var links = getSymbolLinks(symbol); + return getVariancesWorker(links.typeParameters, links, function (_links, param, marker) { + var type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, makeUnaryTypeMapper(param, marker))); + type.aliasTypeArgumentsContainsMarker = true; + return type; + }); + } + function getVariancesWorker(typeParameters, cache, createMarkerType) { + if (typeParameters === void 0) { typeParameters = ts.emptyArray; } + var variances = cache.variances; + if (!variances) { + cache.variances = ts.emptyArray; + variances = []; + var _loop_14 = function (tp) { + var unmeasurable = false; + var unreliable = false; + var oldHandler = outofbandVarianceMarkerHandler; + outofbandVarianceMarkerHandler = function (onlyUnreliable) { return onlyUnreliable ? unreliable = true : unmeasurable = true; }; + var typeWithSuper = createMarkerType(cache, tp, markerSuperType); + var typeWithSub = createMarkerType(cache, tp, markerSubType); + var variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 : 0) | + (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 : 0); + if (variance === 3 && isTypeAssignableTo(createMarkerType(cache, tp, markerOtherType), typeWithSuper)) { + variance = 4; + } + outofbandVarianceMarkerHandler = oldHandler; + if (unmeasurable || unreliable) { + if (unmeasurable) { + variance |= 8; + } + if (unreliable) { + variance |= 16; + } + } + variances.push(variance); + }; + for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) { + var tp = typeParameters_1[_i]; + _loop_14(tp); + } + cache.variances = variances; + } + return variances; + } + function getVariances(type) { + if (type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8) { + return arrayVariances; + } + return getVariancesWorker(type.typeParameters, type, getMarkerTypeReference); + } + function hasCovariantVoidArgument(typeArguments, variances) { + for (var i = 0; i < variances.length; i++) { + if ((variances[i] & 7) === 1 && typeArguments[i].flags & 16384) { + return true; + } + } + return false; + } + function isUnconstrainedTypeParameter(type) { + return type.flags & 262144 && !getConstraintOfTypeParameter(type); + } + function isNonDeferredTypeReference(type) { + return !!(ts.getObjectFlags(type) & 4) && !type.node; + } + function isTypeReferenceWithGenericArguments(type) { + return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t); }); + } + function getTypeReferenceId(type, typeParameters, depth) { + if (depth === void 0) { depth = 0; } + var result = "" + type.target.id; + for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) { + var t = _a[_i]; + if (isUnconstrainedTypeParameter(t)) { + var index = typeParameters.indexOf(t); + if (index < 0) { + index = typeParameters.length; + typeParameters.push(t); + } + result += "=" + index; + } + else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) { + result += "<" + getTypeReferenceId(t, typeParameters, depth + 1) + ">"; + } + else { + result += "-" + t.id; + } + } + return result; + } + function getRelationKey(source, target, intersectionState, relation) { + if (relation === identityRelation && source.id > target.id) { + var temp = source; + source = target; + target = temp; + } + var postFix = intersectionState ? ":" + intersectionState : ""; + if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) { + var typeParameters = []; + return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix; + } + return source.id + "," + target.id + postFix; + } + function forEachProperty(prop, callback) { + if (ts.getCheckFlags(prop) & 6) { + for (var _i = 0, _a = prop.containingType.types; _i < _a.length; _i++) { + var t = _a[_i]; + var p = getPropertyOfType(t, prop.escapedName); + var result = p && forEachProperty(p, callback); + if (result) { + return result; + } + } + return undefined; + } + return callback(prop); + } + function getDeclaringClass(prop) { + return prop.parent && prop.parent.flags & 32 ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined; + } + function isPropertyInClassDerivedFrom(prop, baseClass) { + return forEachProperty(prop, function (sp) { + var sourceClass = getDeclaringClass(sp); + return sourceClass ? hasBaseType(sourceClass, baseClass) : false; + }); + } + function isValidOverrideOf(sourceProp, targetProp) { + return !forEachProperty(targetProp, function (tp) { return ts.getDeclarationModifierFlagsFromSymbol(tp) & 16 ? + !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false; }); + } + function isClassDerivedFromDeclaringClasses(checkClass, prop) { + return forEachProperty(prop, function (p) { return ts.getDeclarationModifierFlagsFromSymbol(p) & 16 ? + !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass; + } + function isDeeplyNestedType(type, stack, depth) { + if (depth >= 5 && type.flags & 524288 && !isObjectOrArrayLiteralType(type)) { + var symbol = type.symbol; + if (symbol) { + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & 524288 && t.symbol === symbol) { + count++; + if (count >= 5) + return true; + } + } + } + } + if (depth >= 5 && type.flags & 8388608) { + var root = getRootObjectTypeFromIndexedAccessChain(type); + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (getRootObjectTypeFromIndexedAccessChain(t) === root) { + count++; + if (count >= 5) + return true; + } + } + } + return false; + } + function getRootObjectTypeFromIndexedAccessChain(type) { + var t = type; + while (t.flags & 8388608) { + t = t.objectType; + } + return t; + } + function isPropertyIdenticalTo(sourceProp, targetProp) { + return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0; + } + function compareProperties(sourceProp, targetProp, compareTypes) { + if (sourceProp === targetProp) { + return -1; + } + var sourcePropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(sourceProp) & 24; + var targetPropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(targetProp) & 24; + if (sourcePropAccessibility !== targetPropAccessibility) { + return 0; + } + if (sourcePropAccessibility) { + if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) { + return 0; + } + } + else { + if ((sourceProp.flags & 16777216) !== (targetProp.flags & 16777216)) { + return 0; + } + } + if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) { + return 0; + } + return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + function isMatchingSignature(source, target, partialMatch) { + var sourceParameterCount = getParameterCount(source); + var targetParameterCount = getParameterCount(target); + var sourceMinArgumentCount = getMinArgumentCount(source); + var targetMinArgumentCount = getMinArgumentCount(target); + var sourceHasRestParameter = hasEffectiveRestParameter(source); + var targetHasRestParameter = hasEffectiveRestParameter(target); + if (sourceParameterCount === targetParameterCount && + sourceMinArgumentCount === targetMinArgumentCount && + sourceHasRestParameter === targetHasRestParameter) { + return true; + } + if (partialMatch && sourceMinArgumentCount <= targetMinArgumentCount) { + return true; + } + return false; + } + function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) { + if (source === target) { + return -1; + } + if (!(isMatchingSignature(source, target, partialMatch))) { + return 0; + } + if (ts.length(source.typeParameters) !== ts.length(target.typeParameters)) { + return 0; + } + if (target.typeParameters) { + var mapper = createTypeMapper(source.typeParameters, target.typeParameters); + for (var i = 0; i < target.typeParameters.length; i++) { + var s = source.typeParameters[i]; + var t = target.typeParameters[i]; + if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) && + compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) { + return 0; + } + } + source = instantiateSignature(source, mapper, true); + } + var result = -1; + if (!ignoreThisTypes) { + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + var related = compareTypes(sourceThisType, targetThisType); + if (!related) { + return 0; + } + result &= related; + } + } + } + var targetLen = getParameterCount(target); + for (var i = 0; i < targetLen; i++) { + var s = getTypeAtPosition(source, i); + var t = getTypeAtPosition(target, i); + var related = compareTypes(t, s); + if (!related) { + return 0; + } + result &= related; + } + if (!ignoreReturnTypes) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + var targetTypePredicate = getTypePredicateOfSignature(target); + result &= sourceTypePredicate || targetTypePredicate ? + compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) : + compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + return result; + } + function compareTypePredicatesIdentical(source, target, compareTypes) { + return !(source && target && typePredicateKindsMatch(source, target)) ? 0 : + source.type === target.type ? -1 : + source.type && target.type ? compareTypes(source.type, target.type) : + 0; + } + function literalTypesWithSameBaseType(types) { + var commonBaseType; + for (var _i = 0, types_11 = types; _i < types_11.length; _i++) { + var t = types_11[_i]; + var baseType = getBaseTypeOfLiteralType(t); + if (!commonBaseType) { + commonBaseType = baseType; + } + if (baseType === t || baseType !== commonBaseType) { + return false; + } + } + return true; + } + function getSupertypeOrUnion(types) { + return literalTypesWithSameBaseType(types) ? + getUnionType(types) : + ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; }); + } + function getCommonSupertype(types) { + if (!strictNullChecks) { + return getSupertypeOrUnion(types); + } + var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304); }); + return primaryTypes.length ? + getNullableType(getSupertypeOrUnion(primaryTypes), getFalsyFlagsOfTypes(types) & 98304) : + getUnionType(types, 2); + } + function getCommonSubtype(types) { + return ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(t, s) ? t : s; }); + } + function isArrayType(type) { + return !!(ts.getObjectFlags(type) & 4) && (type.target === globalArrayType || type.target === globalReadonlyArrayType); + } + function isReadonlyArrayType(type) { + return !!(ts.getObjectFlags(type) & 4) && type.target === globalReadonlyArrayType; + } + function isMutableArrayOrTuple(type) { + return isArrayType(type) && !isReadonlyArrayType(type) || isTupleType(type) && !type.target.readonly; + } + function getElementTypeOfArrayType(type) { + return isArrayType(type) ? getTypeArguments(type)[0] : undefined; + } + function isArrayLikeType(type) { + return isArrayType(type) || !(type.flags & 98304) && isTypeAssignableTo(type, anyReadonlyArrayType); + } + function isEmptyArrayLiteralType(type) { + var elementType = isArrayType(type) ? getTypeArguments(type)[0] : undefined; + return elementType === undefinedWideningType || elementType === implicitNeverType; + } + function isTupleLikeType(type) { + return isTupleType(type) || !!getPropertyOfType(type, "0"); + } + function isArrayOrTupleLikeType(type) { + return isArrayLikeType(type) || isTupleLikeType(type); + } + function getTupleElementType(type, index) { + var propType = getTypeOfPropertyOfType(type, "" + index); + if (propType) { + return propType; + } + if (everyType(type, isTupleType)) { + return mapType(type, function (t) { return getRestTypeOfTupleType(t) || undefinedType; }); + } + return undefined; + } + function isNeitherUnitTypeNorNever(type) { + return !(type.flags & (109440 | 131072)); + } + function isUnitType(type) { + return !!(type.flags & 109440); + } + function isLiteralType(type) { + return type.flags & 16 ? true : + type.flags & 1048576 ? type.flags & 1024 ? true : ts.every(type.types, isUnitType) : + isUnitType(type); + } + function getBaseTypeOfLiteralType(type) { + return type.flags & 1024 ? getBaseTypeOfEnumLiteralType(type) : + type.flags & 128 ? stringType : + type.flags & 256 ? numberType : + type.flags & 2048 ? bigintType : + type.flags & 512 ? booleanType : + type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getBaseTypeOfLiteralType)) : + type; + } + function getWidenedLiteralType(type) { + return type.flags & 1024 && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) : + type.flags & 128 && isFreshLiteralType(type) ? stringType : + type.flags & 256 && isFreshLiteralType(type) ? numberType : + type.flags & 2048 && isFreshLiteralType(type) ? bigintType : + type.flags & 512 && isFreshLiteralType(type) ? booleanType : + type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedLiteralType)) : + type; + } + function getWidenedUniqueESSymbolType(type) { + return type.flags & 8192 ? esSymbolType : + type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedUniqueESSymbolType)) : + type; + } + function getWidenedLiteralLikeTypeForContextualType(type, contextualType) { + if (!isLiteralOfContextualType(type, contextualType)) { + type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type)); + } + return type; + } + function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) { + if (type && isUnitType(type)) { + var contextualType = !contextualSignatureReturnType ? undefined : + isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) : + contextualSignatureReturnType; + type = getWidenedLiteralLikeTypeForContextualType(type, contextualType); + } + return type; + } + function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) { + if (type && isUnitType(type)) { + var contextualType = !contextualSignatureReturnType ? undefined : + getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator); + type = getWidenedLiteralLikeTypeForContextualType(type, contextualType); + } + return type; + } + function isTupleType(type) { + return !!(ts.getObjectFlags(type) & 4 && type.target.objectFlags & 8); + } + function getRestTypeOfTupleType(type) { + return type.target.hasRestElement ? getTypeArguments(type)[type.target.typeParameters.length - 1] : undefined; + } + function getRestArrayTypeOfTupleType(type) { + var restType = getRestTypeOfTupleType(type); + return restType && createArrayType(restType); + } + function getLengthOfTupleType(type) { + return getTypeReferenceArity(type) - (type.target.hasRestElement ? 1 : 0); + } + function isZeroBigInt(_a) { + var value = _a.value; + return value.base10Value === "0"; + } + function getFalsyFlagsOfTypes(types) { + var result = 0; + for (var _i = 0, types_12 = types; _i < types_12.length; _i++) { + var t = types_12[_i]; + result |= getFalsyFlags(t); + } + return result; + } + function getFalsyFlags(type) { + return type.flags & 1048576 ? getFalsyFlagsOfTypes(type.types) : + type.flags & 128 ? type.value === "" ? 128 : 0 : + type.flags & 256 ? type.value === 0 ? 256 : 0 : + type.flags & 2048 ? isZeroBigInt(type) ? 2048 : 0 : + type.flags & 512 ? (type === falseType || type === regularFalseType) ? 512 : 0 : + type.flags & 117724; + } + function removeDefinitelyFalsyTypes(type) { + return getFalsyFlags(type) & 117632 ? + filterType(type, function (t) { return !(getFalsyFlags(t) & 117632); }) : + type; + } + function extractDefinitelyFalsyTypes(type) { + return mapType(type, getDefinitelyFalsyPartOfType); + } + function getDefinitelyFalsyPartOfType(type) { + return type.flags & 4 ? emptyStringType : + type.flags & 8 ? zeroType : + type.flags & 64 ? zeroBigIntType : + type === regularFalseType || + type === falseType || + type.flags & (16384 | 32768 | 65536) || + type.flags & 128 && type.value === "" || + type.flags & 256 && type.value === 0 || + type.flags & 2048 && isZeroBigInt(type) ? type : + neverType; + } + function getNullableType(type, flags) { + var missing = (flags & ~type.flags) & (32768 | 65536); + return missing === 0 ? type : + missing === 32768 ? getUnionType([type, undefinedType]) : + missing === 65536 ? getUnionType([type, nullType]) : + getUnionType([type, undefinedType, nullType]); + } + function getOptionalType(type) { + ts.Debug.assert(strictNullChecks); + return type.flags & 32768 ? type : getUnionType([type, undefinedType]); + } + function getGlobalNonNullableTypeInstantiation(type) { + if (!deferredGlobalNonNullableTypeAlias) { + deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288, undefined) || unknownSymbol; + } + if (deferredGlobalNonNullableTypeAlias !== unknownSymbol) { + return getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]); + } + return getTypeWithFacts(type, 2097152); + } + function getNonNullableType(type) { + return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type; + } + function addOptionalTypeMarker(type) { + return strictNullChecks ? getUnionType([type, optionalType]) : type; + } + function isNotOptionalTypeMarker(type) { + return type !== optionalType; + } + function removeOptionalTypeMarker(type) { + return strictNullChecks ? filterType(type, isNotOptionalTypeMarker) : type; + } + function propagateOptionalTypeMarker(type, node, wasOptional) { + return wasOptional ? ts.isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type; + } + function getOptionalExpressionType(exprType, expression) { + return ts.isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) : + ts.isOptionalChain(expression) ? removeOptionalTypeMarker(exprType) : + exprType; + } + function isCoercibleUnderDoubleEquals(source, target) { + return ((source.flags & (8 | 4 | 512)) !== 0) + && ((target.flags & (8 | 4 | 16)) !== 0); + } + function isObjectTypeWithInferableIndex(type) { + return type.flags & 2097152 ? ts.every(type.types, isObjectTypeWithInferableIndex) : + !!(type.symbol && (type.symbol.flags & (4096 | 2048 | 384 | 512)) !== 0 && + !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 2048 && isObjectTypeWithInferableIndex(type.source)); + } + function createSymbolWithType(source, type) { + var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8); + symbol.declarations = source.declarations; + symbol.parent = source.parent; + symbol.type = type; + symbol.target = source; + if (source.valueDeclaration) { + symbol.valueDeclaration = source.valueDeclaration; + } + var nameType = getSymbolLinks(source).nameType; + if (nameType) { + symbol.nameType = nameType; + } + return symbol; + } + function transformTypeOfMembers(type, f) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) { + var property = _a[_i]; + var original = getTypeOfSymbol(property); + var updated = f(original); + members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated)); + } + return members; + } + function getRegularTypeOfObjectLiteral(type) { + if (!(isObjectLiteralType(type) && ts.getObjectFlags(type) & 32768)) { + return type; + } + var regularType = type.regularType; + if (regularType) { + return regularType; + } + var resolved = type; + var members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral); + var regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, resolved.numberIndexInfo); + regularNew.flags = resolved.flags; + regularNew.objectFlags |= resolved.objectFlags & ~32768; + type.regularType = regularNew; + return regularNew; + } + function createWideningContext(parent, propertyName, siblings) { + return { parent: parent, propertyName: propertyName, siblings: siblings, resolvedProperties: undefined }; + } + function getSiblingsOfContext(context) { + if (!context.siblings) { + var siblings_1 = []; + for (var _i = 0, _a = getSiblingsOfContext(context.parent); _i < _a.length; _i++) { + var type = _a[_i]; + if (isObjectLiteralType(type)) { + var prop = getPropertyOfObjectType(type, context.propertyName); + if (prop) { + forEachType(getTypeOfSymbol(prop), function (t) { + siblings_1.push(t); + }); + } + } + } + context.siblings = siblings_1; + } + return context.siblings; + } + function getPropertiesOfContext(context) { + if (!context.resolvedProperties) { + var names = ts.createMap(); + for (var _i = 0, _a = getSiblingsOfContext(context); _i < _a.length; _i++) { + var t = _a[_i]; + if (isObjectLiteralType(t) && !(ts.getObjectFlags(t) & 1024)) { + for (var _b = 0, _c = getPropertiesOfType(t); _b < _c.length; _b++) { + var prop = _c[_b]; + names.set(prop.escapedName, prop); + } + } + } + context.resolvedProperties = ts.arrayFrom(names.values()); + } + return context.resolvedProperties; + } + function getWidenedProperty(prop, context) { + if (!(prop.flags & 4)) { + return prop; + } + var original = getTypeOfSymbol(prop); + var propContext = context && createWideningContext(context, prop.escapedName, undefined); + var widened = getWidenedTypeWithContext(original, propContext); + return widened === original ? prop : createSymbolWithType(prop, widened); + } + function getUndefinedProperty(prop) { + var cached = undefinedProperties.get(prop.escapedName); + if (cached) { + return cached; + } + var result = createSymbolWithType(prop, undefinedType); + result.flags |= 16777216; + undefinedProperties.set(prop.escapedName, result); + return result; + } + function getWidenedTypeOfObjectLiteral(type, context) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + members.set(prop.escapedName, getWidenedProperty(prop, context)); + } + if (context) { + for (var _b = 0, _c = getPropertiesOfContext(context); _b < _c.length; _b++) { + var prop = _c[_b]; + if (!members.has(prop.escapedName)) { + members.set(prop.escapedName, getUndefinedProperty(prop)); + } + } + } + var stringIndexInfo = getIndexInfoOfType(type, 0); + var numberIndexInfo = getIndexInfoOfType(type, 1); + var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly)); + result.objectFlags |= (ts.getObjectFlags(type) & (16384 | 2097152)); + return result; + } + function getWidenedType(type) { + return getWidenedTypeWithContext(type, undefined); + } + function getWidenedTypeWithContext(type, context) { + if (ts.getObjectFlags(type) & 1572864) { + if (context === undefined && type.widened) { + return type.widened; + } + var result = void 0; + if (type.flags & (1 | 98304)) { + result = anyType; + } + else if (isObjectLiteralType(type)) { + result = getWidenedTypeOfObjectLiteral(type, context); + } + else if (type.flags & 1048576) { + var unionContext_1 = context || createWideningContext(undefined, undefined, type.types); + var widenedTypes = ts.sameMap(type.types, function (t) { return t.flags & 98304 ? t : getWidenedTypeWithContext(t, unionContext_1); }); + result = getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 : 1); + } + else if (type.flags & 2097152) { + result = getIntersectionType(ts.sameMap(type.types, getWidenedType)); + } + else if (isArrayType(type) || isTupleType(type)) { + result = createTypeReference(type.target, ts.sameMap(getTypeArguments(type), getWidenedType)); + } + if (result && context === undefined) { + type.widened = result; + } + return result || type; + } + return type; + } + function reportWideningErrorsInType(type) { + var errorReported = false; + if (ts.getObjectFlags(type) & 524288) { + if (type.flags & 1048576) { + if (ts.some(type.types, isEmptyObjectType)) { + errorReported = true; + } + else { + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (reportWideningErrorsInType(t)) { + errorReported = true; + } + } + } + } + if (isArrayType(type) || isTupleType(type)) { + for (var _b = 0, _c = getTypeArguments(type); _b < _c.length; _b++) { + var t = _c[_b]; + if (reportWideningErrorsInType(t)) { + errorReported = true; + } + } + } + if (isObjectLiteralType(type)) { + for (var _d = 0, _e = getPropertiesOfObjectType(type); _d < _e.length; _d++) { + var p = _e[_d]; + var t = getTypeOfSymbol(p); + if (ts.getObjectFlags(t) & 524288) { + if (!reportWideningErrorsInType(t)) { + error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t))); + } + errorReported = true; + } + } + } + } + return errorReported; + } + function reportImplicitAny(declaration, type, wideningKind) { + var typeAsString = typeToString(getWidenedType(type)); + if (ts.isInJSFile(declaration) && !ts.isCheckJsEnabledForFile(ts.getSourceFileOfNode(declaration), compilerOptions)) { + return; + } + var diagnostic; + switch (declaration.kind) { + case 209: + case 159: + case 158: + diagnostic = noImplicitAny ? ts.Diagnostics.Member_0_implicitly_has_an_1_type : ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 156: + var param = declaration; + if (ts.isIdentifier(param.name) && + (ts.isCallSignatureDeclaration(param.parent) || ts.isMethodSignature(param.parent) || ts.isFunctionTypeNode(param.parent)) && + param.parent.parameters.indexOf(param) > -1 && + (resolveName(param, param.name.escapedText, 788968, undefined, param.name.escapedText, true) || + param.name.originalKeywordKind && ts.isTypeNodeKind(param.name.originalKeywordKind))) { + var newName = "arg" + param.parent.parameters.indexOf(param); + errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, ts.declarationNameToString(param.name)); + return; + } + diagnostic = declaration.dotDotDotToken ? + noImplicitAny ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage : + noImplicitAny ? ts.Diagnostics.Parameter_0_implicitly_has_an_1_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 191: + diagnostic = ts.Diagnostics.Binding_element_0_implicitly_has_an_1_type; + if (!noImplicitAny) { + return; + } + break; + case 300: + error(declaration, ts.Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); + return; + case 244: + case 161: + case 160: + case 163: + case 164: + case 201: + case 202: + if (noImplicitAny && !declaration.name) { + if (wideningKind === 1) { + error(declaration, ts.Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString); + } + else { + error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); + } + return; + } + diagnostic = !noImplicitAny ? ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage : + wideningKind === 1 ? ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type : + ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type; + break; + case 186: + if (noImplicitAny) { + error(declaration, ts.Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type); + } + return; + default: + diagnostic = noImplicitAny ? ts.Diagnostics.Variable_0_implicitly_has_an_1_type : ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + } + errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString); + } + function reportErrorsFromWidening(declaration, type, wideningKind) { + if (produceDiagnostics && noImplicitAny && ts.getObjectFlags(type) & 524288) { + if (!reportWideningErrorsInType(type)) { + reportImplicitAny(declaration, type, wideningKind); + } + } + } + function applyToParameterTypes(source, target, callback) { + var sourceCount = getParameterCount(source); + var targetCount = getParameterCount(target); + var sourceRestType = getEffectiveRestType(source); + var targetRestType = getEffectiveRestType(target); + var targetNonRestCount = targetRestType ? targetCount - 1 : targetCount; + var paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount); + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + callback(sourceThisType, targetThisType); + } + } + for (var i = 0; i < paramCount; i++) { + callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i)); + } + if (targetRestType) { + callback(getRestTypeAtPosition(source, paramCount), targetRestType); + } + } + function applyToReturnTypes(source, target, callback) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + var targetTypePredicate = getTypePredicateOfSignature(target); + if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) { + callback(sourceTypePredicate.type, targetTypePredicate.type); + } + else { + callback(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + } + function createInferenceContext(typeParameters, signature, flags, compareTypes) { + return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable); + } + function cloneInferenceContext(context, extraFlags) { + if (extraFlags === void 0) { extraFlags = 0; } + return context && createInferenceContextWorker(ts.map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes); + } + function createInferenceContextWorker(inferences, signature, flags, compareTypes) { + var context = { + inferences: inferences, + signature: signature, + flags: flags, + compareTypes: compareTypes, + mapper: function (t) { return mapToInferredType(context, t, true); }, + nonFixingMapper: function (t) { return mapToInferredType(context, t, false); }, + }; + return context; + } + function mapToInferredType(context, t, fix) { + var inferences = context.inferences; + for (var i = 0; i < inferences.length; i++) { + var inference = inferences[i]; + if (t === inference.typeParameter) { + if (fix && !inference.isFixed) { + clearCachedInferences(inferences); + inference.isFixed = true; + } + return getInferredType(context, i); + } + } + return t; + } + function clearCachedInferences(inferences) { + for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) { + var inference = inferences_1[_i]; + if (!inference.isFixed) { + inference.inferredType = undefined; + } + } + } + function createInferenceInfo(typeParameter) { + return { + typeParameter: typeParameter, + candidates: undefined, + contraCandidates: undefined, + inferredType: undefined, + priority: undefined, + topLevel: true, + isFixed: false + }; + } + function cloneInferenceInfo(inference) { + return { + typeParameter: inference.typeParameter, + candidates: inference.candidates && inference.candidates.slice(), + contraCandidates: inference.contraCandidates && inference.contraCandidates.slice(), + inferredType: inference.inferredType, + priority: inference.priority, + topLevel: inference.topLevel, + isFixed: inference.isFixed + }; + } + function cloneInferredPartOfContext(context) { + var inferences = ts.filter(context.inferences, hasInferenceCandidates); + return inferences.length ? + createInferenceContextWorker(ts.map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : + undefined; + } + function getMapperFromContext(context) { + return context && context.mapper; + } + function couldContainTypeVariables(type) { + var objectFlags = ts.getObjectFlags(type); + return !!(type.flags & 63176704 || + objectFlags & 4 && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) || + objectFlags & 16 && type.symbol && type.symbol.flags & (16 | 8192 | 32 | 2048 | 4096) && type.symbol.declarations || + objectFlags & (32 | 131072) || + type.flags & 3145728 && !(type.flags & 1024) && couldUnionOrIntersectionContainTypeVariables(type)); + } + function couldUnionOrIntersectionContainTypeVariables(type) { + if (type.couldContainTypeVariables === undefined) { + type.couldContainTypeVariables = ts.some(type.types, couldContainTypeVariables); + } + return type.couldContainTypeVariables; + } + function isTypeParameterAtTopLevel(type, typeParameter) { + return !!(type === typeParameter || + type.flags & 3145728 && ts.some(type.types, function (t) { return isTypeParameterAtTopLevel(t, typeParameter); }) || + type.flags & 16777216 && (isTypeParameterAtTopLevel(getTrueTypeFromConditionalType(type), typeParameter) || + isTypeParameterAtTopLevel(getFalseTypeFromConditionalType(type), typeParameter))); + } + function createEmptyObjectTypeFromStringLiteral(type) { + var members = ts.createSymbolTable(); + forEachType(type, function (t) { + if (!(t.flags & 128)) { + return; + } + var name = ts.escapeLeadingUnderscores(t.value); + var literalProp = createSymbol(4, name); + literalProp.type = anyType; + if (t.symbol) { + literalProp.declarations = t.symbol.declarations; + literalProp.valueDeclaration = t.symbol.valueDeclaration; + } + members.set(name, literalProp); + }); + var indexInfo = type.flags & 4 ? createIndexInfo(emptyObjectType, false) : undefined; + return createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, indexInfo, undefined); + } + function inferTypeForHomomorphicMappedType(source, target, constraint) { + var key = source.id + "," + target.id + "," + constraint.id; + if (reverseMappedCache.has(key)) { + return reverseMappedCache.get(key); + } + reverseMappedCache.set(key, undefined); + var type = createReverseMappedType(source, target, constraint); + reverseMappedCache.set(key, type); + return type; + } + function isPartiallyInferableType(type) { + return !(ts.getObjectFlags(type) & 2097152) || + isObjectLiteralType(type) && ts.some(getPropertiesOfType(type), function (prop) { return isPartiallyInferableType(getTypeOfSymbol(prop)); }); + } + function createReverseMappedType(source, target, constraint) { + if (!(getIndexInfoOfType(source, 0) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) { + return undefined; + } + if (isArrayType(source)) { + return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source)); + } + if (isTupleType(source)) { + var elementTypes = ts.map(getTypeArguments(source), function (t) { return inferReverseMappedType(t, target, constraint); }); + var minLength = getMappedTypeModifiers(target) & 4 ? + getTypeReferenceArity(source) - (source.target.hasRestElement ? 1 : 0) : source.target.minLength; + return createTupleType(elementTypes, minLength, source.target.hasRestElement, source.target.readonly, source.target.associatedNames); + } + var reversed = createObjectType(2048 | 16, undefined); + reversed.source = source; + reversed.mappedType = target; + reversed.constraintType = constraint; + return reversed; + } + function getTypeOfReverseMappedSymbol(symbol) { + return inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType); + } + function inferReverseMappedType(sourceType, target, constraint) { + var typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target)); + var templateType = getTemplateTypeFromMappedType(target); + var inference = createInferenceInfo(typeParameter); + inferTypes([inference], sourceType, templateType); + return getTypeFromInference(inference) || unknownType; + } + function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) { + var properties, _i, properties_2, targetProp, sourceProp, targetType, sourceType; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + properties = getPropertiesOfType(target); + _i = 0, properties_2 = properties; + _a.label = 1; + case 1: + if (!(_i < properties_2.length)) return [3, 6]; + targetProp = properties_2[_i]; + if (isStaticPrivateIdentifierProperty(targetProp)) { + return [3, 5]; + } + if (!(requireOptionalProperties || !(targetProp.flags & 16777216 || ts.getCheckFlags(targetProp) & 48))) return [3, 5]; + sourceProp = getPropertyOfType(source, targetProp.escapedName); + if (!!sourceProp) return [3, 3]; + return [4, targetProp]; + case 2: + _a.sent(); + return [3, 5]; + case 3: + if (!matchDiscriminantProperties) return [3, 5]; + targetType = getTypeOfSymbol(targetProp); + if (!(targetType.flags & 109440)) return [3, 5]; + sourceType = getTypeOfSymbol(sourceProp); + if (!!(sourceType.flags & 1 || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) return [3, 5]; + return [4, targetProp]; + case 4: + _a.sent(); + _a.label = 5; + case 5: + _i++; + return [3, 1]; + case 6: return [2]; + } + }); + } + function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) { + var result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next(); + if (!result.done) + return result.value; + } + function tupleTypesDefinitelyUnrelated(source, target) { + return target.target.minLength > source.target.minLength || + !getRestTypeOfTupleType(target) && (!!getRestTypeOfTupleType(source) || getLengthOfTupleType(target) < getLengthOfTupleType(source)); + } + function typesDefinitelyUnrelated(source, target) { + return isTupleType(source) && isTupleType(target) && tupleTypesDefinitelyUnrelated(source, target) || + !!getUnmatchedProperty(source, target, false, true) && + !!getUnmatchedProperty(target, source, false, true); + } + function getTypeFromInference(inference) { + return inference.candidates ? getUnionType(inference.candidates, 2) : + inference.contraCandidates ? getIntersectionType(inference.contraCandidates) : + undefined; + } + function hasSkipDirectInferenceFlag(node) { + return !!getNodeLinks(node).skipDirectInference; + } + function isFromInferenceBlockedSource(type) { + return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag)); + } + function inferTypes(inferences, originalSource, originalTarget, priority, contravariant) { + if (priority === void 0) { priority = 0; } + if (contravariant === void 0) { contravariant = false; } + var symbolStack; + var visited; + var bivariant = false; + var propagationType; + var inferencePriority = 512; + var allowComplexConstraintInference = true; + inferFromTypes(originalSource, originalTarget); + function inferFromTypes(source, target) { + if (!couldContainTypeVariables(target)) { + return; + } + if (source === wildcardType) { + var savePropagationType = propagationType; + propagationType = source; + inferFromTypes(target, target); + propagationType = savePropagationType; + return; + } + if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) { + inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol)); + return; + } + if (source === target && source.flags & 3145728) { + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + inferFromTypes(t, t); + } + return; + } + if (target.flags & 1048576) { + var _b = inferFromMatchingTypes(source.flags & 1048576 ? source.types : [source], target.types, isTypeOrBaseIdenticalTo), tempSources = _b[0], tempTargets = _b[1]; + var _c = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy), sources = _c[0], targets = _c[1]; + if (targets.length === 0) { + return; + } + target = getUnionType(targets); + if (sources.length === 0) { + inferWithPriority(source, target, 1); + return; + } + source = getUnionType(sources); + } + else if (target.flags & 2097152 && ts.some(target.types, function (t) { return !!getInferenceInfoForType(t) || (isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)); })) { + if (!(source.flags & 1048576)) { + var _d = inferFromMatchingTypes(source.flags & 2097152 ? source.types : [source], target.types, isTypeIdenticalTo), sources = _d[0], targets = _d[1]; + if (sources.length === 0 || targets.length === 0) { + return; + } + source = getIntersectionType(sources); + target = getIntersectionType(targets); + } + } + else if (target.flags & (8388608 | 33554432)) { + target = getActualTypeVariable(target); + } + if (target.flags & 8650752) { + if (ts.getObjectFlags(source) & 2097152 || source === nonInferrableAnyType || source === silentNeverType || + (priority & 32 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) { + return; + } + var inference = getInferenceInfoForType(target); + if (inference) { + if (!inference.isFixed) { + if (inference.priority === undefined || priority < inference.priority) { + inference.candidates = undefined; + inference.contraCandidates = undefined; + inference.topLevel = true; + inference.priority = priority; + } + if (priority === inference.priority) { + var candidate = propagationType || source; + if (contravariant && !bivariant) { + if (!ts.contains(inference.contraCandidates, candidate)) { + inference.contraCandidates = ts.append(inference.contraCandidates, candidate); + clearCachedInferences(inferences); + } + } + else if (!ts.contains(inference.candidates, candidate)) { + inference.candidates = ts.append(inference.candidates, candidate); + clearCachedInferences(inferences); + } + } + if (!(priority & 32) && target.flags & 262144 && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) { + inference.topLevel = false; + clearCachedInferences(inferences); + } + } + inferencePriority = Math.min(inferencePriority, priority); + return; + } + else { + var simplified = getSimplifiedType(target, false); + if (simplified !== target) { + invokeOnce(source, simplified, inferFromTypes); + } + else if (target.flags & 8388608) { + var indexType = getSimplifiedType(target.indexType, false); + if (indexType.flags & 63176704) { + var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false); + if (simplified_1 && simplified_1 !== target) { + invokeOnce(source, simplified_1, inferFromTypes); + } + } + } + } + } + if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target)) && + !(source.node && target.node)) { + inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target)); + } + else if (source.flags & 4194304 && target.flags & 4194304) { + contravariant = !contravariant; + inferFromTypes(source.type, target.type); + contravariant = !contravariant; + } + else if ((isLiteralType(source) || source.flags & 4) && target.flags & 4194304) { + var empty = createEmptyObjectTypeFromStringLiteral(source); + contravariant = !contravariant; + inferWithPriority(empty, target.type, 64); + contravariant = !contravariant; + } + else if (source.flags & 8388608 && target.flags & 8388608) { + inferFromTypes(source.objectType, target.objectType); + inferFromTypes(source.indexType, target.indexType); + } + else if (source.flags & 16777216 && target.flags & 16777216) { + inferFromTypes(source.checkType, target.checkType); + inferFromTypes(source.extendsType, target.extendsType); + inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target)); + inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target)); + } + else if (target.flags & 16777216) { + var savePriority = priority; + priority |= contravariant ? 16 : 0; + var targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)]; + inferToMultipleTypes(source, targetTypes, target.flags); + priority = savePriority; + } + else if (target.flags & 3145728) { + inferToMultipleTypes(source, target.types, target.flags); + } + else if (source.flags & 1048576) { + var sourceTypes = source.types; + for (var _e = 0, sourceTypes_3 = sourceTypes; _e < sourceTypes_3.length; _e++) { + var sourceType = sourceTypes_3[_e]; + inferFromTypes(sourceType, target); + } + } + else { + if (!(priority & 128 && source.flags & (2097152 | 63176704))) { + var apparentSource = getApparentType(source); + if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 | 2097152))) { + allowComplexConstraintInference = false; + return inferFromTypes(apparentSource, target); + } + source = apparentSource; + } + if (source.flags & (524288 | 2097152)) { + invokeOnce(source, target, inferFromObjectTypes); + } + } + if (source.flags & 25165824) { + var simplified = getSimplifiedType(source, contravariant); + if (simplified !== source) { + inferFromTypes(simplified, target); + } + } + } + function inferWithPriority(source, target, newPriority) { + var savePriority = priority; + priority |= newPriority; + inferFromTypes(source, target); + priority = savePriority; + } + function invokeOnce(source, target, action) { + var key = source.id + "," + target.id; + var status = visited && visited.get(key); + if (status !== undefined) { + inferencePriority = Math.min(inferencePriority, status); + return; + } + (visited || (visited = ts.createMap())).set(key, -1); + var saveInferencePriority = inferencePriority; + inferencePriority = 512; + action(source, target); + visited.set(key, inferencePriority); + inferencePriority = Math.min(inferencePriority, saveInferencePriority); + } + function inferFromMatchingTypes(sources, targets, matches) { + var matchedSources; + var matchedTargets; + for (var _i = 0, targets_1 = targets; _i < targets_1.length; _i++) { + var t = targets_1[_i]; + for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) { + var s = sources_1[_a]; + if (matches(s, t)) { + inferFromTypes(s, t); + matchedSources = ts.appendIfUnique(matchedSources, s); + matchedTargets = ts.appendIfUnique(matchedTargets, t); + } + } + } + return [ + matchedSources ? ts.filter(sources, function (t) { return !ts.contains(matchedSources, t); }) : sources, + matchedTargets ? ts.filter(targets, function (t) { return !ts.contains(matchedTargets, t); }) : targets, + ]; + } + function inferFromTypeArguments(sourceTypes, targetTypes, variances) { + var count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length; + for (var i = 0; i < count; i++) { + if (i < variances.length && (variances[i] & 7) === 2) { + inferFromContravariantTypes(sourceTypes[i], targetTypes[i]); + } + else { + inferFromTypes(sourceTypes[i], targetTypes[i]); + } + } + } + function inferFromContravariantTypes(source, target) { + if (strictFunctionTypes || priority & 256) { + contravariant = !contravariant; + inferFromTypes(source, target); + contravariant = !contravariant; + } + else { + inferFromTypes(source, target); + } + } + function getInferenceInfoForType(type) { + if (type.flags & 8650752) { + for (var _i = 0, inferences_2 = inferences; _i < inferences_2.length; _i++) { + var inference = inferences_2[_i]; + if (type === inference.typeParameter) { + return inference; + } + } + } + return undefined; + } + function getSingleTypeVariableFromIntersectionTypes(types) { + var typeVariable; + for (var _i = 0, types_13 = types; _i < types_13.length; _i++) { + var type = types_13[_i]; + var t = type.flags & 2097152 && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); }); + if (!t || typeVariable && t !== typeVariable) { + return undefined; + } + typeVariable = t; + } + return typeVariable; + } + function inferToMultipleTypes(source, targets, targetFlags) { + var typeVariableCount = 0; + if (targetFlags & 1048576) { + var nakedTypeVariable = void 0; + var sources = source.flags & 1048576 ? source.types : [source]; + var matched_1 = new Array(sources.length); + var inferenceCircularity = false; + for (var _i = 0, targets_2 = targets; _i < targets_2.length; _i++) { + var t = targets_2[_i]; + if (getInferenceInfoForType(t)) { + nakedTypeVariable = t; + typeVariableCount++; + } + else { + for (var i = 0; i < sources.length; i++) { + var saveInferencePriority = inferencePriority; + inferencePriority = 512; + inferFromTypes(sources[i], t); + if (inferencePriority === priority) + matched_1[i] = true; + inferenceCircularity = inferenceCircularity || inferencePriority === -1; + inferencePriority = Math.min(inferencePriority, saveInferencePriority); + } + } + } + if (typeVariableCount === 0) { + var intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets); + if (intersectionTypeVariable) { + inferWithPriority(source, intersectionTypeVariable, 1); + } + return; + } + if (typeVariableCount === 1 && !inferenceCircularity) { + var unmatched = ts.flatMap(sources, function (s, i) { return matched_1[i] ? undefined : s; }); + if (unmatched.length) { + inferFromTypes(getUnionType(unmatched), nakedTypeVariable); + return; + } + } + } + else { + for (var _a = 0, targets_3 = targets; _a < targets_3.length; _a++) { + var t = targets_3[_a]; + if (getInferenceInfoForType(t)) { + typeVariableCount++; + } + else { + inferFromTypes(source, t); + } + } + } + if (targetFlags & 2097152 ? typeVariableCount === 1 : typeVariableCount > 0) { + for (var _b = 0, targets_4 = targets; _b < targets_4.length; _b++) { + var t = targets_4[_b]; + if (getInferenceInfoForType(t)) { + inferWithPriority(source, t, 1); + } + } + } + } + function inferToMappedType(source, target, constraintType) { + if (constraintType.flags & 1048576) { + var result = false; + for (var _i = 0, _a = constraintType.types; _i < _a.length; _i++) { + var type = _a[_i]; + result = inferToMappedType(source, target, type) || result; + } + return result; + } + if (constraintType.flags & 4194304) { + var inference = getInferenceInfoForType(constraintType.type); + if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) { + var inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType); + if (inferredType) { + inferWithPriority(inferredType, inference.typeParameter, ts.getObjectFlags(source) & 2097152 ? + 4 : + 2); + } + } + return true; + } + if (constraintType.flags & 262144) { + inferWithPriority(getIndexType(source), constraintType, 8); + var extendedConstraint = getConstraintOfType(constraintType); + if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) { + return true; + } + var propTypes = ts.map(getPropertiesOfType(source), getTypeOfSymbol); + var stringIndexType = getIndexTypeOfType(source, 0); + var numberIndexInfo = getNonEnumNumberIndexInfo(source); + var numberIndexType = numberIndexInfo && numberIndexInfo.type; + inferFromTypes(getUnionType(ts.append(ts.append(propTypes, stringIndexType), numberIndexType)), getTemplateTypeFromMappedType(target)); + return true; + } + return false; + } + function inferFromObjectTypes(source, target) { + var isNonConstructorObject = target.flags & 524288 && + !(ts.getObjectFlags(target) & 16 && target.symbol && target.symbol.flags & 32); + var symbol = isNonConstructorObject ? target.symbol : undefined; + if (symbol) { + if (ts.contains(symbolStack, symbol)) { + inferencePriority = -1; + return; + } + (symbolStack || (symbolStack = [])).push(symbol); + inferFromObjectTypesWorker(source, target); + symbolStack.pop(); + } + else { + inferFromObjectTypesWorker(source, target); + } + } + function inferFromObjectTypesWorker(source, target) { + if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target))) { + inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target)); + return; + } + if (isGenericMappedType(source) && isGenericMappedType(target)) { + inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target)); + inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target)); + } + if (ts.getObjectFlags(target) & 32) { + var constraintType = getConstraintTypeFromMappedType(target); + if (inferToMappedType(source, target, constraintType)) { + return; + } + } + if (!typesDefinitelyUnrelated(source, target)) { + inferFromProperties(source, target); + inferFromSignatures(source, target, 0); + inferFromSignatures(source, target, 1); + inferFromIndexTypes(source, target); + } + } + function inferFromProperties(source, target) { + if (isArrayType(source) || isTupleType(source)) { + if (isTupleType(target)) { + var sourceLength = isTupleType(source) ? getLengthOfTupleType(source) : 0; + var targetLength = getLengthOfTupleType(target); + var sourceRestType = isTupleType(source) ? getRestTypeOfTupleType(source) : getElementTypeOfArrayType(source); + var targetRestType = getRestTypeOfTupleType(target); + var fixedLength = targetLength < sourceLength || sourceRestType ? targetLength : sourceLength; + for (var i = 0; i < fixedLength; i++) { + inferFromTypes(i < sourceLength ? getTypeArguments(source)[i] : sourceRestType, getTypeArguments(target)[i]); + } + if (targetRestType) { + var types = fixedLength < sourceLength ? getTypeArguments(source).slice(fixedLength, sourceLength) : []; + if (sourceRestType) { + types.push(sourceRestType); + } + if (types.length) { + inferFromTypes(getUnionType(types), targetRestType); + } + } + return; + } + if (isArrayType(target)) { + inferFromIndexTypes(source, target); + return; + } + } + var properties = getPropertiesOfObjectType(target); + for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) { + var targetProp = properties_3[_i]; + var sourceProp = getPropertyOfType(source, targetProp.escapedName); + if (sourceProp) { + inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + } + } + function inferFromSignatures(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + var sourceLen = sourceSignatures.length; + var targetLen = targetSignatures.length; + var len = sourceLen < targetLen ? sourceLen : targetLen; + var skipParameters = !!(ts.getObjectFlags(source) & 2097152); + for (var i = 0; i < len; i++) { + inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters); + } + } + function inferFromSignature(source, target, skipParameters) { + if (!skipParameters) { + var saveBivariant = bivariant; + var kind = target.declaration ? target.declaration.kind : 0; + bivariant = bivariant || kind === 161 || kind === 160 || kind === 162; + applyToParameterTypes(source, target, inferFromContravariantTypes); + bivariant = saveBivariant; + } + applyToReturnTypes(source, target, inferFromTypes); + } + function inferFromIndexTypes(source, target) { + var targetStringIndexType = getIndexTypeOfType(target, 0); + if (targetStringIndexType) { + var sourceIndexType = getIndexTypeOfType(source, 0) || + getImplicitIndexTypeOfType(source, 0); + if (sourceIndexType) { + inferFromTypes(sourceIndexType, targetStringIndexType); + } + } + var targetNumberIndexType = getIndexTypeOfType(target, 1); + if (targetNumberIndexType) { + var sourceIndexType = getIndexTypeOfType(source, 1) || + getIndexTypeOfType(source, 0) || + getImplicitIndexTypeOfType(source, 1); + if (sourceIndexType) { + inferFromTypes(sourceIndexType, targetNumberIndexType); + } + } + } + } + function isTypeOrBaseIdenticalTo(s, t) { + return isTypeIdenticalTo(s, t) || !!(s.flags & (128 | 256)) && isTypeIdenticalTo(getBaseTypeOfLiteralType(s), t); + } + function isTypeCloselyMatchedBy(s, t) { + return !!(s.flags & 524288 && t.flags & 524288 && s.symbol && s.symbol === t.symbol || + s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol); + } + function hasPrimitiveConstraint(type) { + var constraint = getConstraintOfTypeParameter(type); + return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 | 4194304); + } + function isObjectLiteralType(type) { + return !!(ts.getObjectFlags(type) & 128); + } + function isObjectOrArrayLiteralType(type) { + return !!(ts.getObjectFlags(type) & (128 | 65536)); + } + function unionObjectAndArrayLiteralCandidates(candidates) { + if (candidates.length > 1) { + var objectLiterals = ts.filter(candidates, isObjectOrArrayLiteralType); + if (objectLiterals.length) { + var literalsType = getUnionType(objectLiterals, 2); + return ts.concatenate(ts.filter(candidates, function (t) { return !isObjectOrArrayLiteralType(t); }), [literalsType]); + } + } + return candidates; + } + function getContravariantInference(inference) { + return inference.priority & 104 ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates); + } + function getCovariantInference(inference, signature) { + var candidates = unionObjectAndArrayLiteralCandidates(inference.candidates); + var primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter); + var widenLiteralTypes = !primitiveConstraint && inference.topLevel && + (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter)); + var baseCandidates = primitiveConstraint ? ts.sameMap(candidates, getRegularTypeOfLiteralType) : + widenLiteralTypes ? ts.sameMap(candidates, getWidenedLiteralType) : + candidates; + var unwidenedType = inference.priority & 104 ? + getUnionType(baseCandidates, 2) : + getCommonSupertype(baseCandidates); + return getWidenedType(unwidenedType); + } + function getInferredType(context, index) { + var inference = context.inferences[index]; + if (!inference.inferredType) { + var inferredType = void 0; + var signature = context.signature; + if (signature) { + var inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : undefined; + if (inference.contraCandidates) { + var inferredContravariantType = getContravariantInference(inference); + inferredType = inferredCovariantType && !(inferredCovariantType.flags & 131072) && + isTypeSubtypeOf(inferredCovariantType, inferredContravariantType) ? + inferredCovariantType : inferredContravariantType; + } + else if (inferredCovariantType) { + inferredType = inferredCovariantType; + } + else if (context.flags & 1) { + inferredType = silentNeverType; + } + else { + var defaultType = getDefaultFromTypeParameter(inference.typeParameter); + if (defaultType) { + inferredType = instantiateType(defaultType, combineTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper)); + } + } + } + else { + inferredType = getTypeFromInference(inference); + } + inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2)); + var constraint = getConstraintOfTypeParameter(inference.typeParameter); + if (constraint) { + var instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper); + if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) { + inference.inferredType = inferredType = instantiatedConstraint; + } + } + } + return inference.inferredType; + } + function getDefaultTypeArgumentType(isInJavaScriptFile) { + return isInJavaScriptFile ? anyType : unknownType; + } + function getInferredTypes(context) { + var result = []; + for (var i = 0; i < context.inferences.length; i++) { + result.push(getInferredType(context, i)); + } + return result; + } + function getCannotFindNameDiagnosticForName(node) { + switch (node.escapedText) { + case "document": + case "console": + return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom; + case "$": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery; + case "describe": + case "suite": + case "it": + case "test": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha; + case "process": + case "require": + case "Buffer": + case "module": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode; + case "Map": + case "Set": + case "Promise": + case "Symbol": + case "WeakMap": + case "WeakSet": + case "Iterator": + case "AsyncIterator": + return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later; + default: + if (node.parent.kind === 282) { + return ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer; + } + else { + return ts.Diagnostics.Cannot_find_name_0; + } + } + } + function getResolvedSymbol(node) { + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + links.resolvedSymbol = !ts.nodeIsMissing(node) && + resolveName(node, node.escapedText, 111551 | 1048576, getCannotFindNameDiagnosticForName(node), node, !ts.isWriteOnlyAccess(node), false, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1) || unknownSymbol; + } + return links.resolvedSymbol; + } + function isInTypeQuery(node) { + return !!ts.findAncestor(node, function (n) { return n.kind === 172 ? true : n.kind === 75 || n.kind === 153 ? false : "quit"; }); + } + function getFlowCacheKey(node, declaredType, initialType, flowContainer) { + switch (node.kind) { + case 75: + var symbol = getResolvedSymbol(node); + return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + (isConstraintPosition(node) ? "@" : "") + getSymbolId(symbol) : undefined; + case 104: + return "0"; + case 218: + case 200: + return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer); + case 194: + case 195: + var propName = getAccessedPropertyName(node); + if (propName !== undefined) { + var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer); + return key && key + "." + propName; + } + } + return undefined; + } + function isMatchingReference(source, target) { + switch (target.kind) { + case 200: + case 218: + return isMatchingReference(source, target.expression); + } + switch (source.kind) { + case 75: + return target.kind === 75 && getResolvedSymbol(source) === getResolvedSymbol(target) || + (target.kind === 242 || target.kind === 191) && + getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target); + case 104: + return target.kind === 104; + case 102: + return target.kind === 102; + case 218: + case 200: + return isMatchingReference(source.expression, target); + case 194: + case 195: + return ts.isAccessExpression(target) && + getAccessedPropertyName(source) === getAccessedPropertyName(target) && + isMatchingReference(source.expression, target.expression); + } + return false; + } + function getAccessedPropertyName(access) { + return access.kind === 194 ? access.name.escapedText : + ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) : + undefined; + } + function containsMatchingReference(source, target) { + while (ts.isAccessExpression(source)) { + source = source.expression; + if (isMatchingReference(source, target)) { + return true; + } + } + return false; + } + function optionalChainContainsReference(source, target) { + while (ts.isOptionalChain(source)) { + source = source.expression; + if (isMatchingReference(source, target)) { + return true; + } + } + return false; + } + function isDiscriminantProperty(type, name) { + if (type && type.flags & 1048576) { + var prop = getUnionOrIntersectionProperty(type, name); + if (prop && ts.getCheckFlags(prop) & 2) { + if (prop.isDiscriminantProperty === undefined) { + prop.isDiscriminantProperty = + (prop.checkFlags & 192) === 192 && + !maybeTypeOfKind(getTypeOfSymbol(prop), 63176704); + } + return !!prop.isDiscriminantProperty; + } + } + return false; + } + function isSyntheticThisPropertyAccess(expr) { + return ts.isAccessExpression(expr) && expr.expression.kind === 104 && !!(expr.expression.flags & 8); + } + function findDiscriminantProperties(sourceProperties, target) { + var result; + for (var _i = 0, sourceProperties_2 = sourceProperties; _i < sourceProperties_2.length; _i++) { + var sourceProperty = sourceProperties_2[_i]; + if (isDiscriminantProperty(target, sourceProperty.escapedName)) { + if (result) { + result.push(sourceProperty); + continue; + } + result = [sourceProperty]; + } + } + return result; + } + function isOrContainsMatchingReference(source, target) { + return isMatchingReference(source, target) || containsMatchingReference(source, target); + } + function hasMatchingArgument(callExpression, reference) { + if (callExpression.arguments) { + for (var _i = 0, _a = callExpression.arguments; _i < _a.length; _i++) { + var argument = _a[_i]; + if (isOrContainsMatchingReference(reference, argument)) { + return true; + } + } + } + if (callExpression.expression.kind === 194 && + isOrContainsMatchingReference(reference, callExpression.expression.expression)) { + return true; + } + return false; + } + function getFlowNodeId(flow) { + if (!flow.id || flow.id < 0) { + flow.id = nextFlowId; + nextFlowId++; + } + return flow.id; + } + function typeMaybeAssignableTo(source, target) { + if (!(source.flags & 1048576)) { + return isTypeAssignableTo(source, target); + } + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (isTypeAssignableTo(t, target)) { + return true; + } + } + return false; + } + function getAssignmentReducedType(declaredType, assignedType) { + if (declaredType !== assignedType) { + if (assignedType.flags & 131072) { + return assignedType; + } + var reducedType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); }); + if (assignedType.flags & 512 && isFreshLiteralType(assignedType)) { + reducedType = mapType(reducedType, getFreshTypeOfLiteralType); + } + if (isTypeAssignableTo(assignedType, reducedType)) { + return reducedType; + } + } + return declaredType; + } + function getTypeFactsOfTypes(types) { + var result = 0; + for (var _i = 0, types_14 = types; _i < types_14.length; _i++) { + var t = types_14[_i]; + result |= getTypeFacts(t); + } + return result; + } + function isFunctionObjectType(type) { + var resolved = resolveStructuredTypeMembers(type); + return !!(resolved.callSignatures.length || resolved.constructSignatures.length || + resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType)); + } + function getTypeFacts(type) { + var flags = type.flags; + if (flags & 4) { + return strictNullChecks ? 16317953 : 16776705; + } + if (flags & 128) { + var isEmpty = type.value === ""; + return strictNullChecks ? + isEmpty ? 12123649 : 7929345 : + isEmpty ? 12582401 : 16776705; + } + if (flags & (8 | 32)) { + return strictNullChecks ? 16317698 : 16776450; + } + if (flags & 256) { + var isZero = type.value === 0; + return strictNullChecks ? + isZero ? 12123394 : 7929090 : + isZero ? 12582146 : 16776450; + } + if (flags & 64) { + return strictNullChecks ? 16317188 : 16775940; + } + if (flags & 2048) { + var isZero = isZeroBigInt(type); + return strictNullChecks ? + isZero ? 12122884 : 7928580 : + isZero ? 12581636 : 16775940; + } + if (flags & 16) { + return strictNullChecks ? 16316168 : 16774920; + } + if (flags & 528) { + return strictNullChecks ? + (type === falseType || type === regularFalseType) ? 12121864 : 7927560 : + (type === falseType || type === regularFalseType) ? 12580616 : 16774920; + } + if (flags & 524288) { + return ts.getObjectFlags(type) & 16 && isEmptyObjectType(type) ? + strictNullChecks ? 16318463 : 16777215 : + isFunctionObjectType(type) ? + strictNullChecks ? 7880640 : 16728000 : + strictNullChecks ? 7888800 : 16736160; + } + if (flags & (16384 | 32768)) { + return 9830144; + } + if (flags & 65536) { + return 9363232; + } + if (flags & 12288) { + return strictNullChecks ? 7925520 : 16772880; + } + if (flags & 67108864) { + return strictNullChecks ? 7888800 : 16736160; + } + if (flags & 63176704) { + return getTypeFacts(getBaseConstraintOfType(type) || unknownType); + } + if (flags & 3145728) { + return getTypeFactsOfTypes(type.types); + } + return 16777215; + } + function getTypeWithFacts(type, include) { + return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; }); + } + function getTypeWithDefault(type, defaultExpression) { + if (defaultExpression) { + var defaultType = getTypeOfExpression(defaultExpression); + return getUnionType([getTypeWithFacts(type, 524288), defaultType]); + } + return type; + } + function getTypeOfDestructuredProperty(type, name) { + var nameType = getLiteralTypeFromPropertyName(name); + if (!isTypeUsableAsPropertyName(nameType)) + return errorType; + var text = getPropertyNameFromType(nameType); + return getConstraintForLocation(getTypeOfPropertyOfType(type, text), name) || + isNumericLiteralName(text) && getIndexTypeOfType(type, 1) || + getIndexTypeOfType(type, 0) || + errorType; + } + function getTypeOfDestructuredArrayElement(type, index) { + return everyType(type, isTupleLikeType) && getTupleElementType(type, index) || + checkIteratedTypeOrElementType(65, type, undefinedType, undefined) || + errorType; + } + function getTypeOfDestructuredSpreadExpression(type) { + return createArrayType(checkIteratedTypeOrElementType(65, type, undefinedType, undefined) || errorType); + } + function getAssignedTypeOfBinaryExpression(node) { + var isDestructuringDefaultAssignment = node.parent.kind === 192 && isDestructuringAssignmentTarget(node.parent) || + node.parent.kind === 281 && isDestructuringAssignmentTarget(node.parent.parent); + return isDestructuringDefaultAssignment ? + getTypeWithDefault(getAssignedType(node), node.right) : + getTypeOfExpression(node.right); + } + function isDestructuringAssignmentTarget(parent) { + return parent.parent.kind === 209 && parent.parent.left === parent || + parent.parent.kind === 232 && parent.parent.initializer === parent; + } + function getAssignedTypeOfArrayLiteralElement(node, element) { + return getTypeOfDestructuredArrayElement(getAssignedType(node), node.elements.indexOf(element)); + } + function getAssignedTypeOfSpreadExpression(node) { + return getTypeOfDestructuredSpreadExpression(getAssignedType(node.parent)); + } + function getAssignedTypeOfPropertyAssignment(node) { + return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name); + } + function getAssignedTypeOfShorthandPropertyAssignment(node) { + return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer); + } + function getAssignedType(node) { + var parent = node.parent; + switch (parent.kind) { + case 231: + return stringType; + case 232: + return checkRightHandSideOfForOf(parent.expression, parent.awaitModifier) || errorType; + case 209: + return getAssignedTypeOfBinaryExpression(parent); + case 203: + return undefinedType; + case 192: + return getAssignedTypeOfArrayLiteralElement(parent, node); + case 213: + return getAssignedTypeOfSpreadExpression(parent); + case 281: + return getAssignedTypeOfPropertyAssignment(parent); + case 282: + return getAssignedTypeOfShorthandPropertyAssignment(parent); + } + return errorType; + } + function getInitialTypeOfBindingElement(node) { + var pattern = node.parent; + var parentType = getInitialType(pattern.parent); + var type = pattern.kind === 189 ? + getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) : + !node.dotDotDotToken ? + getTypeOfDestructuredArrayElement(parentType, pattern.elements.indexOf(node)) : + getTypeOfDestructuredSpreadExpression(parentType); + return getTypeWithDefault(type, node.initializer); + } + function getTypeOfInitializer(node) { + var links = getNodeLinks(node); + return links.resolvedType || getTypeOfExpression(node); + } + function getInitialTypeOfVariableDeclaration(node) { + if (node.initializer) { + return getTypeOfInitializer(node.initializer); + } + if (node.parent.parent.kind === 231) { + return stringType; + } + if (node.parent.parent.kind === 232) { + return checkRightHandSideOfForOf(node.parent.parent.expression, node.parent.parent.awaitModifier) || errorType; + } + return errorType; + } + function getInitialType(node) { + return node.kind === 242 ? + getInitialTypeOfVariableDeclaration(node) : + getInitialTypeOfBindingElement(node); + } + function isEmptyArrayAssignment(node) { + return node.kind === 242 && node.initializer && + isEmptyArrayLiteral(node.initializer) || + node.kind !== 191 && node.parent.kind === 209 && + isEmptyArrayLiteral(node.parent.right); + } + function getReferenceCandidate(node) { + switch (node.kind) { + case 200: + return getReferenceCandidate(node.expression); + case 209: + switch (node.operatorToken.kind) { + case 62: + return getReferenceCandidate(node.left); + case 27: + return getReferenceCandidate(node.right); + } + } + return node; + } + function getReferenceRoot(node) { + var parent = node.parent; + return parent.kind === 200 || + parent.kind === 209 && parent.operatorToken.kind === 62 && parent.left === node || + parent.kind === 209 && parent.operatorToken.kind === 27 && parent.right === node ? + getReferenceRoot(parent) : node; + } + function getTypeOfSwitchClause(clause) { + if (clause.kind === 277) { + return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression)); + } + return neverType; + } + function getSwitchClauseTypes(switchStatement) { + var links = getNodeLinks(switchStatement); + if (!links.switchTypes) { + links.switchTypes = []; + for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) { + var clause = _a[_i]; + links.switchTypes.push(getTypeOfSwitchClause(clause)); + } + } + return links.switchTypes; + } + function getSwitchClauseTypeOfWitnesses(switchStatement) { + var witnesses = []; + for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) { + var clause = _a[_i]; + if (clause.kind === 277) { + if (ts.isStringLiteralLike(clause.expression)) { + witnesses.push(clause.expression.text); + continue; + } + return ts.emptyArray; + } + witnesses.push(undefined); + } + return witnesses; + } + function eachTypeContainedIn(source, types) { + return source.flags & 1048576 ? !ts.forEach(source.types, function (t) { return !ts.contains(types, t); }) : ts.contains(types, source); + } + function isTypeSubsetOf(source, target) { + return source === target || target.flags & 1048576 && isTypeSubsetOfUnion(source, target); + } + function isTypeSubsetOfUnion(source, target) { + if (source.flags & 1048576) { + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (!containsType(target.types, t)) { + return false; + } + } + return true; + } + if (source.flags & 1024 && getBaseTypeOfEnumLiteralType(source) === target) { + return true; + } + return containsType(target.types, source); + } + function forEachType(type, f) { + return type.flags & 1048576 ? ts.forEach(type.types, f) : f(type); + } + function everyType(type, f) { + return type.flags & 1048576 ? ts.every(type.types, f) : f(type); + } + function filterType(type, f) { + if (type.flags & 1048576) { + var types = type.types; + var filtered = ts.filter(types, f); + return filtered === types ? type : getUnionTypeFromSortedList(filtered, type.objectFlags); + } + return f(type) ? type : neverType; + } + function countTypes(type) { + return type.flags & 1048576 ? type.types.length : 1; + } + function mapType(type, mapper, noReductions) { + if (type.flags & 131072) { + return type; + } + if (!(type.flags & 1048576)) { + return mapper(type); + } + var mappedTypes; + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var t = _a[_i]; + var mapped = mapper(t); + if (mapped) { + if (!mappedTypes) { + mappedTypes = [mapped]; + } + else { + mappedTypes.push(mapped); + } + } + } + return mappedTypes && getUnionType(mappedTypes, noReductions ? 0 : 1); + } + function extractTypesOfKind(type, kind) { + return filterType(type, function (t) { return (t.flags & kind) !== 0; }); + } + function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) { + if (isTypeSubsetOf(stringType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 128) || + isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 256) || + isTypeSubsetOf(bigintType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 2048)) { + return mapType(typeWithPrimitives, function (t) { + return t.flags & 4 ? extractTypesOfKind(typeWithLiterals, 4 | 128) : + t.flags & 8 ? extractTypesOfKind(typeWithLiterals, 8 | 256) : + t.flags & 64 ? extractTypesOfKind(typeWithLiterals, 64 | 2048) : t; + }); + } + return typeWithPrimitives; + } + function isIncomplete(flowType) { + return flowType.flags === 0; + } + function getTypeFromFlowType(flowType) { + return flowType.flags === 0 ? flowType.type : flowType; + } + function createFlowType(type, incomplete) { + return incomplete ? { flags: 0, type: type } : type; + } + function createEvolvingArrayType(elementType) { + var result = createObjectType(256); + result.elementType = elementType; + return result; + } + function getEvolvingArrayType(elementType) { + return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType)); + } + function addEvolvingArrayElementType(evolvingArrayType, node) { + var elementType = getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node)); + return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType])); + } + function createFinalArrayType(elementType) { + return elementType.flags & 131072 ? + autoArrayType : + createArrayType(elementType.flags & 1048576 ? + getUnionType(elementType.types, 2) : + elementType); + } + function getFinalArrayType(evolvingArrayType) { + return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType)); + } + function finalizeEvolvingArrayType(type) { + return ts.getObjectFlags(type) & 256 ? getFinalArrayType(type) : type; + } + function getElementTypeOfEvolvingArrayType(type) { + return ts.getObjectFlags(type) & 256 ? type.elementType : neverType; + } + function isEvolvingArrayTypeList(types) { + var hasEvolvingArrayType = false; + for (var _i = 0, types_15 = types; _i < types_15.length; _i++) { + var t = types_15[_i]; + if (!(t.flags & 131072)) { + if (!(ts.getObjectFlags(t) & 256)) { + return false; + } + hasEvolvingArrayType = true; + } + } + return hasEvolvingArrayType; + } + function getUnionOrEvolvingArrayType(types, subtypeReduction) { + return isEvolvingArrayTypeList(types) ? + getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))) : + getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction); + } + function isEvolvingArrayOperationTarget(node) { + var root = getReferenceRoot(node); + var parent = root.parent; + var isLengthPushOrUnshift = ts.isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" || + parent.parent.kind === 196 + && ts.isIdentifier(parent.name) + && ts.isPushOrUnshiftIdentifier(parent.name)); + var isElementAssignment = parent.kind === 195 && + parent.expression === root && + parent.parent.kind === 209 && + parent.parent.operatorToken.kind === 62 && + parent.parent.left === parent && + !ts.isAssignmentTarget(parent.parent) && + isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296); + return isLengthPushOrUnshift || isElementAssignment; + } + function isDeclarationWithExplicitTypeAnnotation(declaration) { + return !!(declaration && (declaration.kind === 242 || declaration.kind === 156 || + declaration.kind === 159 || declaration.kind === 158) && + ts.getEffectiveTypeAnnotationNode(declaration)); + } + function getExplicitTypeOfSymbol(symbol, diagnostic) { + if (symbol.flags & (16 | 8192 | 32 | 512)) { + return getTypeOfSymbol(symbol); + } + if (symbol.flags & (3 | 4)) { + if (isDeclarationWithExplicitTypeAnnotation(symbol.valueDeclaration)) { + return getTypeOfSymbol(symbol); + } + if (diagnostic && symbol.valueDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(symbol.valueDeclaration, ts.Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol))); + } + } + } + function getTypeOfDottedName(node, diagnostic) { + if (!(node.flags & 16777216)) { + switch (node.kind) { + case 75: + var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node)); + return getExplicitTypeOfSymbol(symbol.flags & 2097152 ? resolveAlias(symbol) : symbol, diagnostic); + case 104: + return getExplicitThisType(node); + case 102: + return checkSuperExpression(node); + case 194: + var type = getTypeOfDottedName(node.expression, diagnostic); + var prop = type && getPropertyOfType(type, node.name.escapedText); + return prop && getExplicitTypeOfSymbol(prop, diagnostic); + case 200: + return getTypeOfDottedName(node.expression, diagnostic); + } + } + } + function getEffectsSignature(node) { + var links = getNodeLinks(node); + var signature = links.effectsSignature; + if (signature === undefined) { + var funcType = void 0; + if (node.parent.kind === 226) { + funcType = getTypeOfDottedName(node.expression, undefined); + } + else if (node.expression.kind !== 102) { + if (ts.isOptionalChain(node)) { + funcType = checkNonNullType(getOptionalExpressionType(checkExpression(node.expression), node.expression), node.expression); + } + else { + funcType = checkNonNullExpression(node.expression); + } + } + var signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0); + var candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] : + ts.some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) : + undefined; + signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature; + } + return signature === unknownSignature ? undefined : signature; + } + function hasTypePredicateOrNeverReturnType(signature) { + return !!(getTypePredicateOfSignature(signature) || + signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072); + } + function getTypePredicateArgument(predicate, callExpression) { + if (predicate.kind === 1 || predicate.kind === 3) { + return callExpression.arguments[predicate.parameterIndex]; + } + var invokedExpression = ts.skipParentheses(callExpression.expression); + return ts.isAccessExpression(invokedExpression) ? ts.skipParentheses(invokedExpression.expression) : undefined; + } + function reportFlowControlError(node) { + var block = ts.findAncestor(node, ts.isFunctionOrModuleBlock); + var sourceFile = ts.getSourceFileOfNode(node); + var span = ts.getSpanOfTokenAtPosition(sourceFile, block.statements.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis)); + } + function isReachableFlowNode(flow) { + var result = isReachableFlowNodeWorker(flow, false); + lastFlowNode = flow; + lastFlowNodeReachable = result; + return result; + } + function isUnlockedReachableFlowNode(flow) { + return !(flow.flags & 4096 && flow.lock.locked) && isReachableFlowNodeWorker(flow, false); + } + function isFalseExpression(expr) { + var node = ts.skipParentheses(expr); + return node.kind === 91 || node.kind === 209 && (node.operatorToken.kind === 55 && (isFalseExpression(node.left) || isFalseExpression(node.right)) || + node.operatorToken.kind === 56 && isFalseExpression(node.left) && isFalseExpression(node.right)); + } + function isReachableFlowNodeWorker(flow, noCacheCheck) { + while (true) { + if (flow === lastFlowNode) { + return lastFlowNodeReachable; + } + var flags = flow.flags; + if (flags & 2048) { + if (!noCacheCheck) { + var id = getFlowNodeId(flow); + var reachable = flowNodeReachable[id]; + return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, true)); + } + noCacheCheck = false; + } + if (flags & (16 | 96 | 256 | 4096)) { + flow = flow.antecedent; + } + else if (flags & 512) { + var signature = getEffectsSignature(flow.node); + if (signature) { + var predicate = getTypePredicateOfSignature(signature); + if (predicate && predicate.kind === 3) { + var predicateArgument = flow.node.arguments[predicate.parameterIndex]; + if (predicateArgument && isFalseExpression(predicateArgument)) { + return false; + } + } + if (getReturnTypeOfSignature(signature).flags & 131072) { + return false; + } + } + flow = flow.antecedent; + } + else if (flags & 4) { + return ts.some(flow.antecedents, isUnlockedReachableFlowNode); + } + else if (flags & 8) { + flow = flow.antecedents[0]; + } + else if (flags & 128) { + if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) { + return false; + } + flow = flow.antecedent; + } + else if (flags & 8192) { + lastFlowNode = undefined; + flow.locked = true; + var result = isReachableFlowNodeWorker(flow.antecedent, false); + flow.locked = false; + return result; + } + else { + return !(flags & 1); + } + } + } + function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, couldBeUninitialized) { + if (initialType === void 0) { initialType = declaredType; } + var key; + var keySet = false; + var flowDepth = 0; + if (flowAnalysisDisabled) { + return errorType; + } + if (!reference.flowNode || !couldBeUninitialized && !(declaredType.flags & 133970943)) { + return declaredType; + } + flowInvocationCount++; + var sharedFlowStart = sharedFlowCount; + var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode)); + sharedFlowCount = sharedFlowStart; + var resultType = ts.getObjectFlags(evolvedType) & 256 && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType); + if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 218 && getTypeWithFacts(resultType, 2097152).flags & 131072) { + return declaredType; + } + return resultType; + function getOrSetCacheKey() { + if (keySet) { + return key; + } + keySet = true; + return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer); + } + function getTypeAtFlowNode(flow) { + if (flowDepth === 2000) { + flowAnalysisDisabled = true; + reportFlowControlError(reference); + return errorType; + } + flowDepth++; + while (true) { + var flags = flow.flags; + if (flags & 2048) { + for (var i = sharedFlowStart; i < sharedFlowCount; i++) { + if (sharedFlowNodes[i] === flow) { + flowDepth--; + return sharedFlowTypes[i]; + } + } + } + var type = void 0; + if (flags & 8192) { + flow.locked = true; + type = getTypeAtFlowNode(flow.antecedent); + flow.locked = false; + } + else if (flags & 4096) { + flow = flow.antecedent; + continue; + } + else if (flags & 16) { + type = getTypeAtFlowAssignment(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 512) { + type = getTypeAtFlowCall(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 96) { + type = getTypeAtFlowCondition(flow); + } + else if (flags & 128) { + type = getTypeAtSwitchClause(flow); + } + else if (flags & 12) { + if (flow.antecedents.length === 1) { + flow = flow.antecedents[0]; + continue; + } + type = flags & 4 ? + getTypeAtFlowBranchLabel(flow) : + getTypeAtFlowLoopLabel(flow); + } + else if (flags & 256) { + type = getTypeAtFlowArrayMutation(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 2) { + var container = flow.node; + if (container && container !== flowContainer && + reference.kind !== 194 && + reference.kind !== 195 && + reference.kind !== 104) { + flow = container.flowNode; + continue; + } + type = initialType; + } + else { + type = convertAutoToAny(declaredType); + } + if (flags & 2048) { + sharedFlowNodes[sharedFlowCount] = flow; + sharedFlowTypes[sharedFlowCount] = type; + sharedFlowCount++; + } + flowDepth--; + return type; + } + } + function getInitialOrAssignedType(flow) { + var node = flow.node; + return getConstraintForLocation(node.kind === 242 || node.kind === 191 ? + getInitialType(node) : + getAssignedType(node), reference); + } + function getTypeAtFlowAssignment(flow) { + var node = flow.node; + if (isMatchingReference(reference, node)) { + if (!isReachableFlowNode(flow)) { + return unreachableNeverType; + } + if (ts.getAssignmentTargetKind(node) === 2) { + var flowType = getTypeAtFlowNode(flow.antecedent); + return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType)); + } + if (declaredType === autoType || declaredType === autoArrayType) { + if (isEmptyArrayAssignment(node)) { + return getEvolvingArrayType(neverType); + } + var assignedType = getBaseTypeOfLiteralType(getInitialOrAssignedType(flow)); + return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType; + } + if (declaredType.flags & 1048576) { + return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow)); + } + return declaredType; + } + if (containsMatchingReference(reference, node)) { + if (!isReachableFlowNode(flow)) { + return unreachableNeverType; + } + if (ts.isVariableDeclaration(node) && (ts.isInJSFile(node) || ts.isVarConst(node))) { + var init = ts.getDeclaredExpandoInitializer(node); + if (init && (init.kind === 201 || init.kind === 202)) { + return getTypeAtFlowNode(flow.antecedent); + } + } + return declaredType; + } + if (ts.isVariableDeclaration(node) && node.parent.parent.kind === 231 && isMatchingReference(reference, node.parent.parent.expression)) { + return getNonNullableTypeIfNeeded(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent))); + } + return undefined; + } + function narrowTypeByAssertion(type, expr) { + var node = ts.skipParentheses(expr); + if (node.kind === 91) { + return unreachableNeverType; + } + if (node.kind === 209) { + if (node.operatorToken.kind === 55) { + return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right); + } + if (node.operatorToken.kind === 56) { + return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]); + } + } + return narrowType(type, node, true); + } + function getTypeAtFlowCall(flow) { + var signature = getEffectsSignature(flow.node); + if (signature) { + var predicate = getTypePredicateOfSignature(signature); + if (predicate && (predicate.kind === 2 || predicate.kind === 3)) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + var narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, true) : + predicate.kind === 3 && predicate.parameterIndex >= 0 && predicate.parameterIndex < flow.node.arguments.length ? narrowTypeByAssertion(type, flow.node.arguments[predicate.parameterIndex]) : + type; + return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType)); + } + if (getReturnTypeOfSignature(signature).flags & 131072) { + return unreachableNeverType; + } + } + return undefined; + } + function getTypeAtFlowArrayMutation(flow) { + if (declaredType === autoType || declaredType === autoArrayType) { + var node = flow.node; + var expr = node.kind === 196 ? + node.expression.expression : + node.left.expression; + if (isMatchingReference(reference, getReferenceCandidate(expr))) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (ts.getObjectFlags(type) & 256) { + var evolvedType_1 = type; + if (node.kind === 196) { + for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) { + var arg = _a[_i]; + evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, arg); + } + } + else { + var indexType = getContextFreeTypeOfExpression(node.left.argumentExpression); + if (isTypeAssignableToKind(indexType, 296)) { + evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, node.right); + } + } + return evolvedType_1 === type ? flowType : createFlowType(evolvedType_1, isIncomplete(flowType)); + } + return flowType; + } + } + return undefined; + } + function getTypeAtFlowCondition(flow) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (type.flags & 131072) { + return flowType; + } + var assumeTrue = (flow.flags & 32) !== 0; + var nonEvolvingType = finalizeEvolvingArrayType(type); + var narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue); + if (narrowedType === nonEvolvingType) { + return flowType; + } + var incomplete = isIncomplete(flowType); + var resultType = incomplete && narrowedType.flags & 131072 ? silentNeverType : narrowedType; + return createFlowType(resultType, incomplete); + } + function getTypeAtSwitchClause(flow) { + var expr = flow.switchStatement.expression; + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (isMatchingReference(reference, expr)) { + type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd); + } + else if (expr.kind === 204 && isMatchingReference(reference, expr.expression)) { + type = narrowBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd); + } + else { + if (strictNullChecks) { + if (optionalChainContainsReference(expr, reference)) { + type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & (32768 | 131072)); }); + } + else if (expr.kind === 204 && optionalChainContainsReference(expr.expression, reference)) { + type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & 131072 || t.flags & 128 && t.value === "undefined"); }); + } + } + if (isMatchingReferenceDiscriminant(expr, type)) { + type = narrowTypeByDiscriminant(type, expr, function (t) { return narrowTypeBySwitchOnDiscriminant(t, flow.switchStatement, flow.clauseStart, flow.clauseEnd); }); + } + } + return createFlowType(type, isIncomplete(flowType)); + } + function getTypeAtFlowBranchLabel(flow) { + var antecedentTypes = []; + var subtypeReduction = false; + var seenIncomplete = false; + var bypassFlow; + for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) { + var antecedent = _a[_i]; + if (antecedent.flags & 4096 && antecedent.lock.locked) { + continue; + } + if (!bypassFlow && antecedent.flags & 128 && antecedent.clauseStart === antecedent.clauseEnd) { + bypassFlow = antecedent; + continue; + } + var flowType = getTypeAtFlowNode(antecedent); + var type = getTypeFromFlowType(flowType); + if (type === declaredType && declaredType === initialType) { + return type; + } + ts.pushIfUnique(antecedentTypes, type); + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + if (isIncomplete(flowType)) { + seenIncomplete = true; + } + } + if (bypassFlow) { + var flowType = getTypeAtFlowNode(bypassFlow); + var type = getTypeFromFlowType(flowType); + if (!ts.contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) { + if (type === declaredType && declaredType === initialType) { + return type; + } + antecedentTypes.push(type); + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + if (isIncomplete(flowType)) { + seenIncomplete = true; + } + } + } + return createFlowType(getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1), seenIncomplete); + } + function getTypeAtFlowLoopLabel(flow) { + var id = getFlowNodeId(flow); + var cache = flowLoopCaches[id] || (flowLoopCaches[id] = ts.createMap()); + var key = getOrSetCacheKey(); + if (!key) { + return declaredType; + } + var cached = cache.get(key); + if (cached) { + return cached; + } + for (var i = flowLoopStart; i < flowLoopCount; i++) { + if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key && flowLoopTypes[i].length) { + return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1), true); + } + } + var antecedentTypes = []; + var subtypeReduction = false; + var firstAntecedentType; + for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) { + var antecedent = _a[_i]; + var flowType = void 0; + if (!firstAntecedentType) { + flowType = firstAntecedentType = getTypeAtFlowNode(antecedent); + } + else { + flowLoopNodes[flowLoopCount] = flow; + flowLoopKeys[flowLoopCount] = key; + flowLoopTypes[flowLoopCount] = antecedentTypes; + flowLoopCount++; + var saveFlowTypeCache = flowTypeCache; + flowTypeCache = undefined; + flowType = getTypeAtFlowNode(antecedent); + flowTypeCache = saveFlowTypeCache; + flowLoopCount--; + var cached_1 = cache.get(key); + if (cached_1) { + return cached_1; + } + } + var type = getTypeFromFlowType(flowType); + ts.pushIfUnique(antecedentTypes, type); + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + if (type === declaredType) { + break; + } + } + var result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1); + if (isIncomplete(firstAntecedentType)) { + return createFlowType(result, true); + } + cache.set(key, result); + return result; + } + function isMatchingReferenceDiscriminant(expr, computedType) { + if (!(computedType.flags & 1048576) || !ts.isAccessExpression(expr)) { + return false; + } + var name = getAccessedPropertyName(expr); + if (name === undefined) { + return false; + } + return isMatchingReference(reference, expr.expression) && isDiscriminantProperty(computedType, name); + } + function narrowTypeByDiscriminant(type, access, narrowType) { + var propName = getAccessedPropertyName(access); + if (propName === undefined) { + return type; + } + var propType = getTypeOfPropertyOfType(type, propName); + if (!propType) { + return type; + } + var narrowedPropType = narrowType(propType); + return filterType(type, function (t) { + var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName); + return !(discriminantType.flags & 131072) && isTypeComparableTo(discriminantType, narrowedPropType); + }); + } + function narrowTypeByTruthiness(type, expr, assumeTrue) { + if (isMatchingReference(reference, expr)) { + return getTypeWithFacts(type, assumeTrue ? 4194304 : 8388608); + } + if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) { + type = getTypeWithFacts(type, 2097152); + } + if (isMatchingReferenceDiscriminant(expr, declaredType)) { + return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumeTrue ? 4194304 : 8388608); }); + } + return type; + } + function isTypePresencePossible(type, propName, assumeTrue) { + if (getIndexInfoOfType(type, 0)) { + return true; + } + var prop = getPropertyOfType(type, propName); + if (prop) { + return prop.flags & 16777216 ? true : assumeTrue; + } + return !assumeTrue; + } + function narrowByInKeyword(type, literal, assumeTrue) { + if (type.flags & (1048576 | 524288) || isThisTypeParameter(type)) { + var propName_1 = ts.escapeLeadingUnderscores(literal.text); + return filterType(type, function (t) { return isTypePresencePossible(t, propName_1, assumeTrue); }); + } + return type; + } + function narrowTypeByBinaryExpression(type, expr, assumeTrue) { + switch (expr.operatorToken.kind) { + case 62: + return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue); + case 34: + case 35: + case 36: + case 37: + var operator_1 = expr.operatorToken.kind; + var left_1 = getReferenceCandidate(expr.left); + var right_1 = getReferenceCandidate(expr.right); + if (left_1.kind === 204 && ts.isStringLiteralLike(right_1)) { + return narrowTypeByTypeof(type, left_1, operator_1, right_1, assumeTrue); + } + if (right_1.kind === 204 && ts.isStringLiteralLike(left_1)) { + return narrowTypeByTypeof(type, right_1, operator_1, left_1, assumeTrue); + } + if (isMatchingReference(reference, left_1)) { + return narrowTypeByEquality(type, operator_1, right_1, assumeTrue); + } + if (isMatchingReference(reference, right_1)) { + return narrowTypeByEquality(type, operator_1, left_1, assumeTrue); + } + if (strictNullChecks) { + if (optionalChainContainsReference(left_1, reference)) { + type = narrowTypeByOptionalChainContainment(type, operator_1, right_1, assumeTrue); + } + else if (optionalChainContainsReference(right_1, reference)) { + type = narrowTypeByOptionalChainContainment(type, operator_1, left_1, assumeTrue); + } + } + if (isMatchingReferenceDiscriminant(left_1, declaredType)) { + return narrowTypeByDiscriminant(type, left_1, function (t) { return narrowTypeByEquality(t, operator_1, right_1, assumeTrue); }); + } + if (isMatchingReferenceDiscriminant(right_1, declaredType)) { + return narrowTypeByDiscriminant(type, right_1, function (t) { return narrowTypeByEquality(t, operator_1, left_1, assumeTrue); }); + } + break; + case 98: + return narrowTypeByInstanceof(type, expr, assumeTrue); + case 97: + var target = getReferenceCandidate(expr.right); + if (ts.isStringLiteralLike(expr.left) && isMatchingReference(reference, target)) { + return narrowByInKeyword(type, expr.left, assumeTrue); + } + break; + case 27: + return narrowType(type, expr.right, assumeTrue); + } + return type; + } + function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) { + var equalsOperator = operator === 34 || operator === 36; + var nullableFlags = operator === 34 || operator === 35 ? 98304 : 32768; + var valueType = getTypeOfExpression(value); + var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) || + equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 | nullableFlags)); }); + return removeNullable ? getTypeWithFacts(type, 2097152) : type; + } + function narrowTypeByEquality(type, operator, value, assumeTrue) { + if (type.flags & 1) { + return type; + } + if (operator === 35 || operator === 37) { + assumeTrue = !assumeTrue; + } + var valueType = getTypeOfExpression(value); + if ((type.flags & 2) && assumeTrue && (operator === 36 || operator === 37)) { + if (valueType.flags & (131068 | 67108864)) { + return valueType; + } + if (valueType.flags & 524288) { + return nonPrimitiveType; + } + return type; + } + if (valueType.flags & 98304) { + if (!strictNullChecks) { + return type; + } + var doubleEquals = operator === 34 || operator === 35; + var facts = doubleEquals ? + assumeTrue ? 262144 : 2097152 : + valueType.flags & 65536 ? + assumeTrue ? 131072 : 1048576 : + assumeTrue ? 65536 : 524288; + return getTypeWithFacts(type, facts); + } + if (type.flags & 67637251) { + return type; + } + if (assumeTrue) { + var filterFn = operator === 34 ? + (function (t) { return areTypesComparable(t, valueType) || isCoercibleUnderDoubleEquals(t, valueType); }) : + function (t) { return areTypesComparable(t, valueType); }; + var narrowedType = filterType(type, filterFn); + return narrowedType.flags & 131072 ? type : replacePrimitivesWithLiterals(narrowedType, valueType); + } + if (isUnitType(valueType)) { + var regularType_1 = getRegularTypeOfLiteralType(valueType); + return filterType(type, function (t) { return getRegularTypeOfLiteralType(t) !== regularType_1; }); + } + return type; + } + function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) { + if (operator === 35 || operator === 37) { + assumeTrue = !assumeTrue; + } + var target = getReferenceCandidate(typeOfExpr.expression); + if (!isMatchingReference(reference, target)) { + if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) { + return getTypeWithFacts(type, 2097152); + } + if (containsMatchingReference(reference, target)) { + return declaredType; + } + return type; + } + if (type.flags & 1 && literal.text === "function") { + return type; + } + var facts = assumeTrue ? + typeofEQFacts.get(literal.text) || 128 : + typeofNEFacts.get(literal.text) || 32768; + return getTypeWithFacts(assumeTrue ? mapType(type, narrowTypeForTypeof) : type, facts); + function narrowTypeForTypeof(type) { + if (type.flags & 2 && literal.text === "object") { + return getUnionType([nonPrimitiveType, nullType]); + } + var targetType = literal.text === "function" ? globalFunctionType : typeofTypesByName.get(literal.text); + if (targetType) { + if (isTypeSubtypeOf(type, targetType)) { + return type; + } + if (isTypeSubtypeOf(targetType, type)) { + return targetType; + } + if (type.flags & 63176704) { + var constraint = getBaseConstraintOfType(type) || anyType; + if (isTypeSubtypeOf(targetType, constraint)) { + return getIntersectionType([type, targetType]); + } + } + } + return type; + } + } + function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) { + var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck); + return everyClauseChecks ? getTypeWithFacts(type, 2097152) : type; + } + function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) { + var switchTypes = getSwitchClauseTypes(switchStatement); + if (!switchTypes.length) { + return type; + } + var clauseTypes = switchTypes.slice(clauseStart, clauseEnd); + var hasDefaultClause = clauseStart === clauseEnd || ts.contains(clauseTypes, neverType); + if ((type.flags & 2) && !hasDefaultClause) { + var groundClauseTypes = void 0; + for (var i = 0; i < clauseTypes.length; i += 1) { + var t = clauseTypes[i]; + if (t.flags & (131068 | 67108864)) { + if (groundClauseTypes !== undefined) { + groundClauseTypes.push(t); + } + } + else if (t.flags & 524288) { + if (groundClauseTypes === undefined) { + groundClauseTypes = clauseTypes.slice(0, i); + } + groundClauseTypes.push(nonPrimitiveType); + } + else { + return type; + } + } + return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes); + } + var discriminantType = getUnionType(clauseTypes); + var caseType = discriminantType.flags & 131072 ? neverType : + replacePrimitivesWithLiterals(filterType(type, function (t) { return areTypesComparable(discriminantType, t); }), discriminantType); + if (!hasDefaultClause) { + return caseType; + } + var defaultType = filterType(type, function (t) { return !(isUnitType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(t))); }); + return caseType.flags & 131072 ? defaultType : getUnionType([caseType, defaultType]); + } + function getImpliedTypeFromTypeofCase(type, text) { + switch (text) { + case "function": + return type.flags & 1 ? type : globalFunctionType; + case "object": + return type.flags & 2 ? getUnionType([nonPrimitiveType, nullType]) : type; + default: + return typeofTypesByName.get(text) || type; + } + } + function narrowTypeForTypeofSwitch(candidate) { + return function (type) { + if (isTypeSubtypeOf(candidate, type)) { + return candidate; + } + if (type.flags & 63176704) { + var constraint = getBaseConstraintOfType(type) || anyType; + if (isTypeSubtypeOf(candidate, constraint)) { + return getIntersectionType([type, candidate]); + } + } + return type; + }; + } + function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) { + var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement); + if (!switchWitnesses.length) { + return type; + } + var defaultCaseLocation = ts.findIndex(switchWitnesses, function (elem) { return elem === undefined; }); + var hasDefaultClause = clauseStart === clauseEnd || (defaultCaseLocation >= clauseStart && defaultCaseLocation < clauseEnd); + var clauseWitnesses; + var switchFacts; + if (defaultCaseLocation > -1) { + var witnesses = switchWitnesses.filter(function (witness) { return witness !== undefined; }); + var fixedClauseStart = defaultCaseLocation < clauseStart ? clauseStart - 1 : clauseStart; + var fixedClauseEnd = defaultCaseLocation < clauseEnd ? clauseEnd - 1 : clauseEnd; + clauseWitnesses = witnesses.slice(fixedClauseStart, fixedClauseEnd); + switchFacts = getFactsFromTypeofSwitch(fixedClauseStart, fixedClauseEnd, witnesses, hasDefaultClause); + } + else { + clauseWitnesses = switchWitnesses.slice(clauseStart, clauseEnd); + switchFacts = getFactsFromTypeofSwitch(clauseStart, clauseEnd, switchWitnesses, hasDefaultClause); + } + if (hasDefaultClause) { + return filterType(type, function (t) { return (getTypeFacts(t) & switchFacts) === switchFacts; }); + } + var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofCase(type, text); })), switchFacts); + if (impliedType.flags & 1048576) { + impliedType = getAssignmentReducedType(impliedType, getBaseConstraintOrType(type)); + } + return getTypeWithFacts(mapType(type, narrowTypeForTypeofSwitch(impliedType)), switchFacts); + } + function narrowTypeByInstanceof(type, expr, assumeTrue) { + var left = getReferenceCandidate(expr.left); + if (!isMatchingReference(reference, left)) { + if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) { + return getTypeWithFacts(type, 2097152); + } + if (containsMatchingReference(reference, left) && !isSyntheticThisPropertyAccess(reference)) { + return declaredType; + } + return type; + } + var rightType = getTypeOfExpression(expr.right); + if (!isTypeDerivedFrom(rightType, globalFunctionType)) { + return type; + } + var targetType; + var prototypeProperty = getPropertyOfType(rightType, "prototype"); + if (prototypeProperty) { + var prototypePropertyType = getTypeOfSymbol(prototypeProperty); + if (!isTypeAny(prototypePropertyType)) { + targetType = prototypePropertyType; + } + } + if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) { + return type; + } + if (!targetType) { + var constructSignatures = getSignaturesOfType(rightType, 1); + targetType = constructSignatures.length ? + getUnionType(ts.map(constructSignatures, function (signature) { return getReturnTypeOfSignature(getErasedSignature(signature)); })) : + emptyObjectType; + } + return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom); + } + function getNarrowedType(type, candidate, assumeTrue, isRelated) { + if (!assumeTrue) { + return filterType(type, function (t) { return !isRelated(t, candidate); }); + } + if (type.flags & 1048576) { + var assignableType = filterType(type, function (t) { return isRelated(t, candidate); }); + if (!(assignableType.flags & 131072)) { + return assignableType; + } + } + return isTypeSubtypeOf(candidate, type) ? candidate : + isTypeAssignableTo(type, candidate) ? type : + isTypeAssignableTo(candidate, type) ? candidate : + getIntersectionType([type, candidate]); + } + function narrowTypeByCallExpression(type, callExpression, assumeTrue) { + if (hasMatchingArgument(callExpression, reference)) { + var signature = assumeTrue || !ts.isCallChain(callExpression) ? getEffectsSignature(callExpression) : undefined; + var predicate = signature && getTypePredicateOfSignature(signature); + if (predicate && (predicate.kind === 0 || predicate.kind === 1)) { + return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue); + } + } + return type; + } + function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) { + if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) { + var predicateArgument = getTypePredicateArgument(predicate, callExpression); + if (predicateArgument) { + if (isMatchingReference(reference, predicateArgument)) { + return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf); + } + if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && + !(getTypeFacts(predicate.type) & 65536)) { + return getTypeWithFacts(type, 2097152); + } + if (containsMatchingReference(reference, predicateArgument)) { + return declaredType; + } + } + } + return type; + } + function narrowType(type, expr, assumeTrue) { + if (ts.isExpressionOfOptionalChainRoot(expr) || + ts.isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 && expr.parent.left === expr) { + return narrowTypeByOptionality(type, expr, assumeTrue); + } + switch (expr.kind) { + case 75: + case 104: + case 102: + case 194: + case 195: + return narrowTypeByTruthiness(type, expr, assumeTrue); + case 196: + return narrowTypeByCallExpression(type, expr, assumeTrue); + case 200: + return narrowType(type, expr.expression, assumeTrue); + case 209: + return narrowTypeByBinaryExpression(type, expr, assumeTrue); + case 207: + if (expr.operator === 53) { + return narrowType(type, expr.operand, !assumeTrue); + } + break; + } + return type; + } + function narrowTypeByOptionality(type, expr, assumePresent) { + if (isMatchingReference(reference, expr)) { + return getTypeWithFacts(type, assumePresent ? 2097152 : 262144); + } + if (isMatchingReferenceDiscriminant(expr, declaredType)) { + return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumePresent ? 2097152 : 262144); }); + } + return type; + } + } + function getTypeOfSymbolAtLocation(symbol, location) { + symbol = symbol.exportSymbol || symbol; + if (location.kind === 75) { + if (ts.isRightSideOfQualifiedNameOrPropertyAccess(location)) { + location = location.parent; + } + if (ts.isExpressionNode(location) && !ts.isAssignmentTarget(location)) { + var type = getTypeOfExpression(location); + if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) { + return type; + } + } + } + return getTypeOfSymbol(symbol); + } + function getControlFlowContainer(node) { + return ts.findAncestor(node.parent, function (node) { + return ts.isFunctionLike(node) && !ts.getImmediatelyInvokedFunctionExpression(node) || + node.kind === 250 || + node.kind === 290 || + node.kind === 159; + }); + } + function isParameterAssigned(symbol) { + var func = ts.getRootDeclaration(symbol.valueDeclaration).parent; + var links = getNodeLinks(func); + if (!(links.flags & 8388608)) { + links.flags |= 8388608; + if (!hasParentWithAssignmentsMarked(func)) { + markParameterAssignments(func); + } + } + return symbol.isAssigned || false; + } + function hasParentWithAssignmentsMarked(node) { + return !!ts.findAncestor(node.parent, function (node) { return ts.isFunctionLike(node) && !!(getNodeLinks(node).flags & 8388608); }); + } + function markParameterAssignments(node) { + if (node.kind === 75) { + if (ts.isAssignmentTarget(node)) { + var symbol = getResolvedSymbol(node); + if (symbol.valueDeclaration && ts.getRootDeclaration(symbol.valueDeclaration).kind === 156) { + symbol.isAssigned = true; + } + } + } + else { + ts.forEachChild(node, markParameterAssignments); + } + } + function isConstVariable(symbol) { + return symbol.flags & 3 && (getDeclarationNodeFlagsFromSymbol(symbol) & 2) !== 0 && getTypeOfSymbol(symbol) !== autoArrayType; + } + function removeOptionalityFromDeclaredType(declaredType, declaration) { + var annotationIncludesUndefined = strictNullChecks && + declaration.kind === 156 && + declaration.initializer && + getFalsyFlags(declaredType) & 32768 && + !(getFalsyFlags(checkExpression(declaration.initializer)) & 32768); + return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288) : declaredType; + } + function isConstraintPosition(node) { + var parent = node.parent; + return parent.kind === 194 || + parent.kind === 196 && parent.expression === node || + parent.kind === 195 && parent.expression === node || + parent.kind === 191 && parent.name === node && !!parent.initializer; + } + function typeHasNullableConstraint(type) { + return type.flags & 58982400 && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 98304); + } + function getConstraintForLocation(type, node) { + if (type && isConstraintPosition(node) && forEachType(type, typeHasNullableConstraint)) { + return mapType(getWidenedType(type), getBaseConstraintOrType); + } + return type; + } + function isExportOrExportExpression(location) { + return !!ts.findAncestor(location, function (e) { return e.parent && ts.isExportAssignment(e.parent) && e.parent.expression === e && ts.isEntityNameExpression(e); }); + } + function markAliasReferenced(symbol, location) { + if (isNonLocalAlias(symbol, 111551) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) { + if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { + markAliasSymbolAsReferenced(symbol); + } + else { + markConstEnumAliasAsReferenced(symbol); + } + } + } + function checkIdentifier(node) { + var symbol = getResolvedSymbol(node); + if (symbol === unknownSymbol) { + return errorType; + } + if (symbol === argumentsSymbol) { + var container = ts.getContainingFunction(node); + if (languageVersion < 2) { + if (container.kind === 202) { + error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); + } + else if (ts.hasModifier(container, 256)) { + error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method); + } + } + getNodeLinks(container).flags |= 8192; + return getTypeOfSymbol(symbol); + } + if (!(node.parent && ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) { + markAliasReferenced(symbol, node); + } + var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); + var declaration = localOrExportSymbol.valueDeclaration; + if (localOrExportSymbol.flags & 32) { + if (declaration.kind === 245 + && ts.nodeIsDecorated(declaration)) { + var container = ts.getContainingClass(node); + while (container !== undefined) { + if (container === declaration && container.name !== node) { + getNodeLinks(declaration).flags |= 16777216; + getNodeLinks(node).flags |= 33554432; + break; + } + container = ts.getContainingClass(container); + } + } + else if (declaration.kind === 214) { + var container = ts.getThisContainer(node, false); + while (container.kind !== 290) { + if (container.parent === declaration) { + if (container.kind === 159 && ts.hasModifier(container, 32)) { + getNodeLinks(declaration).flags |= 16777216; + getNodeLinks(node).flags |= 33554432; + } + break; + } + container = ts.getThisContainer(container, false); + } + } + } + checkNestedBlockScopedBinding(node, symbol); + var type = getConstraintForLocation(getTypeOfSymbol(localOrExportSymbol), node); + var assignmentKind = ts.getAssignmentTargetKind(node); + if (assignmentKind) { + if (!(localOrExportSymbol.flags & 3) && + !(ts.isInJSFile(node) && localOrExportSymbol.flags & 512)) { + error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable, symbolToString(symbol)); + return errorType; + } + if (isReadonlySymbol(localOrExportSymbol)) { + if (localOrExportSymbol.flags & 3) { + error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol)); + } + else { + error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol)); + } + return errorType; + } + } + var isAlias = localOrExportSymbol.flags & 2097152; + if (localOrExportSymbol.flags & 3) { + if (assignmentKind === 1) { + return type; + } + } + else if (isAlias) { + declaration = ts.find(symbol.declarations, isSomeImportDeclaration); + } + else { + return type; + } + if (!declaration) { + return type; + } + var isParameter = ts.getRootDeclaration(declaration).kind === 156; + var declarationContainer = getControlFlowContainer(declaration); + var flowContainer = getControlFlowContainer(node); + var isOuterVariable = flowContainer !== declarationContainer; + var isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && ts.isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent); + var isModuleExports = symbol.flags & 134217728; + while (flowContainer !== declarationContainer && (flowContainer.kind === 201 || + flowContainer.kind === 202 || ts.isObjectLiteralOrClassExpressionMethod(flowContainer)) && + (isConstVariable(localOrExportSymbol) || isParameter && !isParameterAssigned(localOrExportSymbol))) { + flowContainer = getControlFlowContainer(flowContainer); + } + var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || ts.isBindingElement(declaration) || + type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 | 16384)) !== 0 || + isInTypeQuery(node) || node.parent.kind === 263) || + node.parent.kind === 218 || + declaration.kind === 242 && declaration.exclamationToken || + declaration.flags & 8388608; + var initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, declaration) : type) : + type === autoType || type === autoArrayType ? undefinedType : + getOptionalType(type); + var flowType = getFlowTypeOfReference(node, type, initialType, flowContainer, !assumeInitialized); + if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) { + if (flowType === autoType || flowType === autoArrayType) { + if (noImplicitAny) { + error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType)); + error(node, ts.Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType)); + } + return convertAutoToAny(flowType); + } + } + else if (!assumeInitialized && !(getFalsyFlags(type) & 32768) && getFalsyFlags(flowType) & 32768) { + error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol)); + return type; + } + return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType; + } + function isInsideFunction(node, threshold) { + return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n); }); + } + function getPartOfForStatementContainingNode(node, container) { + return ts.findAncestor(node, function (n) { return n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement; }); + } + function checkNestedBlockScopedBinding(node, symbol) { + if (languageVersion >= 2 || + (symbol.flags & (2 | 32)) === 0 || + ts.isSourceFile(symbol.valueDeclaration) || + symbol.valueDeclaration.parent.kind === 280) { + return; + } + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + var usedInFunction = isInsideFunction(node.parent, container); + var current = container; + var containedInIterationStatement = false; + while (current && !ts.nodeStartsNewLexicalEnvironment(current)) { + if (ts.isIterationStatement(current, false)) { + containedInIterationStatement = true; + break; + } + current = current.parent; + } + if (containedInIterationStatement) { + if (usedInFunction) { + var capturesBlockScopeBindingInLoopBody = true; + if (ts.isForStatement(container)) { + var varDeclList = ts.getAncestor(symbol.valueDeclaration, 243); + if (varDeclList && varDeclList.parent === container) { + var part = getPartOfForStatementContainingNode(node.parent, container); + if (part) { + var links = getNodeLinks(part); + links.flags |= 131072; + var capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []); + ts.pushIfUnique(capturedBindings, symbol); + if (part === container.initializer) { + capturesBlockScopeBindingInLoopBody = false; + } + } + } + } + if (capturesBlockScopeBindingInLoopBody) { + getNodeLinks(current).flags |= 65536; + } + } + if (ts.isForStatement(container)) { + var varDeclList = ts.getAncestor(symbol.valueDeclaration, 243); + if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) { + getNodeLinks(symbol.valueDeclaration).flags |= 4194304; + } + } + getNodeLinks(symbol.valueDeclaration).flags |= 524288; + } + if (usedInFunction) { + getNodeLinks(symbol.valueDeclaration).flags |= 262144; + } + } + function isBindingCapturedByNode(node, decl) { + var links = getNodeLinks(node); + return !!links && ts.contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl)); + } + function isAssignedInBodyOfForStatement(node, container) { + var current = node; + while (current.parent.kind === 200) { + current = current.parent; + } + var isAssigned = false; + if (ts.isAssignmentTarget(current)) { + isAssigned = true; + } + else if ((current.parent.kind === 207 || current.parent.kind === 208)) { + var expr = current.parent; + isAssigned = expr.operator === 45 || expr.operator === 46; + } + if (!isAssigned) { + return false; + } + return !!ts.findAncestor(current, function (n) { return n === container ? "quit" : n === container.statement; }); + } + function captureLexicalThis(node, container) { + getNodeLinks(node).flags |= 2; + if (container.kind === 159 || container.kind === 162) { + var classNode = container.parent; + getNodeLinks(classNode).flags |= 4; + } + else { + getNodeLinks(container).flags |= 4; + } + } + function findFirstSuperCall(n) { + if (ts.isSuperCall(n)) { + return n; + } + else if (ts.isFunctionLike(n)) { + return undefined; + } + return ts.forEachChild(n, findFirstSuperCall); + } + function getSuperCallInConstructor(constructor) { + var links = getNodeLinks(constructor); + if (links.hasSuperCall === undefined) { + links.superCall = findFirstSuperCall(constructor.body); + links.hasSuperCall = links.superCall ? true : false; + } + return links.superCall; + } + function classDeclarationExtendsNull(classDecl) { + var classSymbol = getSymbolOfNode(classDecl); + var classInstanceType = getDeclaredTypeOfSymbol(classSymbol); + var baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType); + return baseConstructorType === nullWideningType; + } + function checkThisBeforeSuper(node, container, diagnosticMessage) { + var containingClassDecl = container.parent; + var baseTypeNode = ts.getClassExtendsHeritageElement(containingClassDecl); + if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) { + var superCall = getSuperCallInConstructor(container); + if (!superCall || superCall.end > node.pos) { + error(node, diagnosticMessage); + } + } + } + function checkThisExpression(node) { + var container = ts.getThisContainer(node, true); + var capturedByArrowFunction = false; + if (container.kind === 162) { + checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class); + } + if (container.kind === 202) { + container = ts.getThisContainer(container, false); + capturedByArrowFunction = true; + } + switch (container.kind) { + case 249: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); + break; + case 248: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); + break; + case 162: + if (isInConstructorArgumentInitializer(node, container)) { + error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); + } + break; + case 159: + case 158: + if (ts.hasModifier(container, 32)) { + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); + } + break; + case 154: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); + break; + } + if (capturedByArrowFunction && languageVersion < 2) { + captureLexicalThis(node, container); + } + var type = tryGetThisTypeAt(node, true, container); + if (noImplicitThis) { + var globalThisType_1 = getTypeOfSymbol(globalThisSymbol); + if (type === globalThisType_1 && capturedByArrowFunction) { + error(node, ts.Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this); + } + else if (!type) { + var diag = error(node, ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation); + if (!ts.isSourceFile(container)) { + var outsideThis = tryGetThisTypeAt(container); + if (outsideThis && outsideThis !== globalThisType_1) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(container, ts.Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container)); + } + } + } + } + return type || anyType; + } + function tryGetThisTypeAt(node, includeGlobalThis, container) { + if (includeGlobalThis === void 0) { includeGlobalThis = true; } + if (container === void 0) { container = ts.getThisContainer(node, false); } + var isInJS = ts.isInJSFile(node); + if (ts.isFunctionLike(container) && + (!isInParameterInitializerBeforeContainingFunction(node) || ts.getThisParameter(container))) { + var className = getClassNameFromPrototypeMethod(container); + if (isInJS && className) { + var classSymbol = checkExpression(className).symbol; + if (classSymbol && classSymbol.members && (classSymbol.flags & 16)) { + var classType = getDeclaredTypeOfSymbol(classSymbol).thisType; + return getFlowTypeOfReference(node, classType); + } + } + else if (isInJS && + (container.kind === 201 || container.kind === 244) && + ts.getJSDocClassTag(container)) { + var classType = getDeclaredTypeOfSymbol(getMergedSymbol(container.symbol)).thisType; + return getFlowTypeOfReference(node, classType); + } + var thisType = getThisTypeOfDeclaration(container) || getContextualThisParameterType(container); + if (thisType) { + return getFlowTypeOfReference(node, thisType); + } + } + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); + var type = ts.hasModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType; + return getFlowTypeOfReference(node, type); + } + if (isInJS) { + var type = getTypeForThisExpressionFromJSDoc(container); + if (type && type !== errorType) { + return getFlowTypeOfReference(node, type); + } + } + if (ts.isSourceFile(container)) { + if (container.commonJsModuleIndicator) { + var fileSymbol = getSymbolOfNode(container); + return fileSymbol && getTypeOfSymbol(fileSymbol); + } + else if (includeGlobalThis) { + return getTypeOfSymbol(globalThisSymbol); + } + } + } + function getExplicitThisType(node) { + var container = ts.getThisContainer(node, false); + if (ts.isFunctionLike(container)) { + var signature = getSignatureFromDeclaration(container); + if (signature.thisParameter) { + return getExplicitTypeOfSymbol(signature.thisParameter); + } + } + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); + return ts.hasModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType; + } + } + function getClassNameFromPrototypeMethod(container) { + if (container.kind === 201 && + ts.isBinaryExpression(container.parent) && + ts.getAssignmentDeclarationKind(container.parent) === 3) { + return container.parent + .left + .expression + .expression; + } + else if (container.kind === 161 && + container.parent.kind === 193 && + ts.isBinaryExpression(container.parent.parent) && + ts.getAssignmentDeclarationKind(container.parent.parent) === 6) { + return container.parent.parent.left.expression; + } + else if (container.kind === 201 && + container.parent.kind === 281 && + container.parent.parent.kind === 193 && + ts.isBinaryExpression(container.parent.parent.parent) && + ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 6) { + return container.parent.parent.parent.left.expression; + } + else if (container.kind === 201 && + ts.isPropertyAssignment(container.parent) && + ts.isIdentifier(container.parent.name) && + (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") && + ts.isObjectLiteralExpression(container.parent.parent) && + ts.isCallExpression(container.parent.parent.parent) && + container.parent.parent.parent.arguments[2] === container.parent.parent && + ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 9) { + return container.parent.parent.parent.arguments[0].expression; + } + else if (ts.isMethodDeclaration(container) && + ts.isIdentifier(container.name) && + (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") && + ts.isObjectLiteralExpression(container.parent) && + ts.isCallExpression(container.parent.parent) && + container.parent.parent.arguments[2] === container.parent && + ts.getAssignmentDeclarationKind(container.parent.parent) === 9) { + return container.parent.parent.arguments[0].expression; + } + } + function getTypeForThisExpressionFromJSDoc(node) { + var jsdocType = ts.getJSDocType(node); + if (jsdocType && jsdocType.kind === 300) { + var jsDocFunctionType = jsdocType; + if (jsDocFunctionType.parameters.length > 0 && + jsDocFunctionType.parameters[0].name && + jsDocFunctionType.parameters[0].name.escapedText === "this") { + return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type); + } + } + var thisTag = ts.getJSDocThisTag(node); + if (thisTag && thisTag.typeExpression) { + return getTypeFromTypeNode(thisTag.typeExpression); + } + } + function isInConstructorArgumentInitializer(node, constructorDecl) { + return !!ts.findAncestor(node, function (n) { return ts.isFunctionLikeDeclaration(n) ? "quit" : n.kind === 156 && n.parent === constructorDecl; }); + } + function checkSuperExpression(node) { + var isCallExpression = node.parent.kind === 196 && node.parent.expression === node; + var container = ts.getSuperContainer(node, true); + var needToCaptureLexicalThis = false; + if (!isCallExpression) { + while (container && container.kind === 202) { + container = ts.getSuperContainer(container, true); + needToCaptureLexicalThis = languageVersion < 2; + } + } + var canUseSuperExpression = isLegalUsageOfSuperExpression(container); + var nodeCheckFlag = 0; + if (!canUseSuperExpression) { + var current = ts.findAncestor(node, function (n) { return n === container ? "quit" : n.kind === 154; }); + if (current && current.kind === 154) { + error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); + } + else if (isCallExpression) { + error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors); + } + else if (!container || !container.parent || !(ts.isClassLike(container.parent) || container.parent.kind === 193)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions); + } + else { + error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class); + } + return errorType; + } + if (!isCallExpression && container.kind === 162) { + checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class); + } + if (ts.hasModifier(container, 32) || isCallExpression) { + nodeCheckFlag = 512; + } + else { + nodeCheckFlag = 256; + } + getNodeLinks(node).flags |= nodeCheckFlag; + if (container.kind === 161 && ts.hasModifier(container, 256)) { + if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) { + getNodeLinks(container).flags |= 4096; + } + else { + getNodeLinks(container).flags |= 2048; + } + } + if (needToCaptureLexicalThis) { + captureLexicalThis(node.parent, container); + } + if (container.parent.kind === 193) { + if (languageVersion < 2) { + error(node, ts.Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher); + return errorType; + } + else { + return anyType; + } + } + var classLikeDeclaration = container.parent; + if (!ts.getClassExtendsHeritageElement(classLikeDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + return errorType; + } + var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + return errorType; + } + if (container.kind === 162 && isInConstructorArgumentInitializer(node, container)) { + error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); + return errorType; + } + return nodeCheckFlag === 512 + ? getBaseConstructorTypeOfClass(classType) + : getTypeWithThisArgument(baseClassType, classType.thisType); + function isLegalUsageOfSuperExpression(container) { + if (!container) { + return false; + } + if (isCallExpression) { + return container.kind === 162; + } + else { + if (ts.isClassLike(container.parent) || container.parent.kind === 193) { + if (ts.hasModifier(container, 32)) { + return container.kind === 161 || + container.kind === 160 || + container.kind === 163 || + container.kind === 164; + } + else { + return container.kind === 161 || + container.kind === 160 || + container.kind === 163 || + container.kind === 164 || + container.kind === 159 || + container.kind === 158 || + container.kind === 162; + } + } + } + return false; + } + } + function getContainingObjectLiteral(func) { + return (func.kind === 161 || + func.kind === 163 || + func.kind === 164) && func.parent.kind === 193 ? func.parent : + func.kind === 201 && func.parent.kind === 281 ? func.parent.parent : + undefined; + } + function getThisTypeArgument(type) { + return ts.getObjectFlags(type) & 4 && type.target === globalThisType ? getTypeArguments(type)[0] : undefined; + } + function getThisTypeFromContextualType(type) { + return mapType(type, function (t) { + return t.flags & 2097152 ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t); + }); + } + function getContextualThisParameterType(func) { + if (func.kind === 202) { + return undefined; + } + if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) { + var contextualSignature = getContextualSignature(func); + if (contextualSignature) { + var thisParameter = contextualSignature.thisParameter; + if (thisParameter) { + return getTypeOfSymbol(thisParameter); + } + } + } + var inJs = ts.isInJSFile(func); + if (noImplicitThis || inJs) { + var containingLiteral = getContainingObjectLiteral(func); + if (containingLiteral) { + var contextualType = getApparentTypeOfContextualType(containingLiteral); + var literal = containingLiteral; + var type = contextualType; + while (type) { + var thisType = getThisTypeFromContextualType(type); + if (thisType) { + return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral))); + } + if (literal.parent.kind !== 281) { + break; + } + literal = literal.parent.parent; + type = getApparentTypeOfContextualType(literal); + } + return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral)); + } + var parent = ts.walkUpParenthesizedExpressions(func.parent); + if (parent.kind === 209 && parent.operatorToken.kind === 62) { + var target = parent.left; + if (ts.isAccessExpression(target)) { + var expression = target.expression; + if (inJs && ts.isIdentifier(expression)) { + var sourceFile = ts.getSourceFileOfNode(parent); + if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) { + return undefined; + } + } + return getWidenedType(checkExpressionCached(expression)); + } + } + } + return undefined; + } + function getContextuallyTypedParameterType(parameter) { + var func = parameter.parent; + if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) { + return undefined; + } + var iife = ts.getImmediatelyInvokedFunctionExpression(func); + if (iife && iife.arguments) { + var args = getEffectiveCallArguments(iife); + var indexOfParameter = func.parameters.indexOf(parameter); + if (parameter.dotDotDotToken) { + return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, undefined); + } + var links = getNodeLinks(iife); + var cached = links.resolvedSignature; + links.resolvedSignature = anySignature; + var type = indexOfParameter < args.length ? + getWidenedLiteralType(checkExpression(args[indexOfParameter])) : + parameter.initializer ? undefined : undefinedWideningType; + links.resolvedSignature = cached; + return type; + } + var contextualSignature = getContextualSignature(func); + if (contextualSignature) { + var index = func.parameters.indexOf(parameter) - (ts.getThisParameter(func) ? 1 : 0); + return parameter.dotDotDotToken && ts.lastOrUndefined(func.parameters) === parameter ? + getRestTypeAtPosition(contextualSignature, index) : + tryGetTypeAtPosition(contextualSignature, index); + } + } + function getContextualTypeForVariableLikeDeclaration(declaration) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + switch (declaration.kind) { + case 156: + return getContextuallyTypedParameterType(declaration); + case 191: + return getContextualTypeForBindingElement(declaration); + } + } + function getContextualTypeForBindingElement(declaration) { + var parent = declaration.parent.parent; + var name = declaration.propertyName || declaration.name; + var parentType = getContextualTypeForVariableLikeDeclaration(parent) || + parent.kind !== 191 && parent.initializer && checkDeclarationInitializer(parent); + if (parentType && !ts.isBindingPattern(name) && !isComputedNonLiteralName(name)) { + var nameType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(nameType)) { + var text = getPropertyNameFromType(nameType); + return getTypeOfPropertyOfType(parentType, text); + } + } + } + function getContextualTypeForInitializerExpression(node) { + var declaration = node.parent; + if (ts.hasInitializer(declaration) && node === declaration.initializer) { + var result = getContextualTypeForVariableLikeDeclaration(declaration); + if (result) { + return result; + } + if (ts.isBindingPattern(declaration.name)) { + return getTypeFromBindingPattern(declaration.name, true, false); + } + } + return undefined; + } + function getContextualTypeForReturnExpression(node) { + var func = ts.getContainingFunction(node); + if (func) { + var functionFlags = ts.getFunctionFlags(func); + if (functionFlags & 1) { + return undefined; + } + var contextualReturnType = getContextualReturnType(func); + if (contextualReturnType) { + if (functionFlags & 2) { + var contextualAwaitedType = getAwaitedTypeOfPromise(contextualReturnType); + return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]); + } + return contextualReturnType; + } + } + return undefined; + } + function getContextualTypeForAwaitOperand(node) { + var contextualType = getContextualType(node); + if (contextualType) { + var contextualAwaitedType = getAwaitedType(contextualType); + return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]); + } + return undefined; + } + function getContextualTypeForYieldOperand(node) { + var func = ts.getContainingFunction(node); + if (func) { + var functionFlags = ts.getFunctionFlags(func); + var contextualReturnType = getContextualReturnType(func); + if (contextualReturnType) { + return node.asteriskToken + ? contextualReturnType + : getIterationTypeOfGeneratorFunctionReturnType(0, contextualReturnType, (functionFlags & 2) !== 0); + } + } + return undefined; + } + function isInParameterInitializerBeforeContainingFunction(node) { + var inBindingInitializer = false; + while (node.parent && !ts.isFunctionLike(node.parent)) { + if (ts.isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) { + return true; + } + if (ts.isBindingElement(node.parent) && node.parent.initializer === node) { + inBindingInitializer = true; + } + node = node.parent; + } + return false; + } + function getContextualIterationType(kind, functionDecl) { + var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2); + var contextualReturnType = getContextualReturnType(functionDecl); + if (contextualReturnType) { + return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync) + || undefined; + } + return undefined; + } + function getContextualReturnType(functionDecl) { + var returnType = getReturnTypeFromAnnotation(functionDecl); + if (returnType) { + return returnType; + } + var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl); + if (signature && !isResolvingReturnTypeOfSignature(signature)) { + return getReturnTypeOfSignature(signature); + } + return undefined; + } + function getContextualTypeForArgument(callTarget, arg) { + var args = getEffectiveCallArguments(callTarget); + var argIndex = args.indexOf(arg); + return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex); + } + function getContextualTypeForArgumentAtIndex(callTarget, argIndex) { + var signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget); + if (ts.isJsxOpeningLikeElement(callTarget) && argIndex === 0) { + return getEffectiveFirstArgumentForJsxSignature(signature, callTarget); + } + return getTypeAtPosition(signature, argIndex); + } + function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { + if (template.parent.kind === 198) { + return getContextualTypeForArgument(template.parent, substitutionExpression); + } + return undefined; + } + function getContextualTypeForBinaryOperand(node, contextFlags) { + var binaryExpression = node.parent; + var left = binaryExpression.left, operatorToken = binaryExpression.operatorToken, right = binaryExpression.right; + switch (operatorToken.kind) { + case 62: + if (node !== right) { + return undefined; + } + var contextSensitive = getIsContextSensitiveAssignmentOrContextType(binaryExpression); + if (!contextSensitive) { + return undefined; + } + return contextSensitive === true ? getTypeOfExpression(left) : contextSensitive; + case 56: + case 60: + var type = getContextualType(binaryExpression, contextFlags); + return node === right && (type && type.pattern || !type && !ts.isDefaultedExpandoInitializer(binaryExpression)) ? + getTypeOfExpression(left) : type; + case 55: + case 27: + return node === right ? getContextualType(binaryExpression, contextFlags) : undefined; + default: + return undefined; + } + } + function getIsContextSensitiveAssignmentOrContextType(binaryExpression) { + var kind = ts.getAssignmentDeclarationKind(binaryExpression); + switch (kind) { + case 0: + return true; + case 5: + case 1: + case 6: + case 3: + if (!binaryExpression.left.symbol) { + return true; + } + else { + var decl = binaryExpression.left.symbol.valueDeclaration; + if (!decl) { + return false; + } + var lhs = ts.cast(binaryExpression.left, ts.isAccessExpression); + var overallAnnotation = ts.getEffectiveTypeAnnotationNode(decl); + if (overallAnnotation) { + return getTypeFromTypeNode(overallAnnotation); + } + else if (ts.isIdentifier(lhs.expression)) { + var id = lhs.expression; + var parentSymbol = resolveName(id, id.escapedText, 111551, undefined, id.escapedText, true); + if (parentSymbol) { + var annotated = ts.getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration); + if (annotated) { + var nameStr_1 = ts.getElementOrPropertyAccessName(lhs); + if (nameStr_1 !== undefined) { + var type = getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated), nameStr_1); + return type || false; + } + } + return false; + } + } + return !ts.isInJSFile(decl); + } + case 2: + case 4: + if (!binaryExpression.symbol) + return true; + if (binaryExpression.symbol.valueDeclaration) { + var annotated = ts.getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration); + if (annotated) { + var type = getTypeFromTypeNode(annotated); + if (type) { + return type; + } + } + } + if (kind === 2) + return false; + var thisAccess = ts.cast(binaryExpression.left, ts.isAccessExpression); + if (!ts.isObjectLiteralMethod(ts.getThisContainer(thisAccess.expression, false))) { + return false; + } + var thisType = checkThisExpression(thisAccess.expression); + var nameStr = ts.getElementOrPropertyAccessName(thisAccess); + return nameStr !== undefined && thisType && getTypeOfPropertyOfContextualType(thisType, nameStr) || false; + case 7: + case 8: + case 9: + return ts.Debug.fail("Does not apply"); + default: + return ts.Debug.assertNever(kind); + } + } + function getTypeOfPropertyOfContextualType(type, name) { + return mapType(type, function (t) { + if (isGenericMappedType(t)) { + var constraint = getConstraintTypeFromMappedType(t); + var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint; + var propertyNameType = getLiteralType(ts.unescapeLeadingUnderscores(name)); + if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) { + return substituteIndexedMappedType(t, propertyNameType); + } + } + else if (t.flags & 3670016) { + var prop = getPropertyOfType(t, name); + if (prop) { + return getTypeOfSymbol(prop); + } + if (isTupleType(t)) { + var restType = getRestTypeOfTupleType(t); + if (restType && isNumericLiteralName(name) && +name >= 0) { + return restType; + } + } + return isNumericLiteralName(name) && getIndexTypeOfContextualType(t, 1) || + getIndexTypeOfContextualType(t, 0); + } + return undefined; + }, true); + } + function getIndexTypeOfContextualType(type, kind) { + return mapType(type, function (t) { return getIndexTypeOfStructuredType(t, kind); }, true); + } + function getContextualTypeForObjectLiteralMethod(node, contextFlags) { + ts.Debug.assert(ts.isObjectLiteralMethod(node)); + if (node.flags & 16777216) { + return undefined; + } + return getContextualTypeForObjectLiteralElement(node, contextFlags); + } + function getContextualTypeForObjectLiteralElement(element, contextFlags) { + var objectLiteral = element.parent; + var type = getApparentTypeOfContextualType(objectLiteral, contextFlags); + if (type) { + if (!hasNonBindableDynamicName(element)) { + var symbolName_3 = getSymbolOfNode(element).escapedName; + var propertyType = getTypeOfPropertyOfContextualType(type, symbolName_3); + if (propertyType) { + return propertyType; + } + } + return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1) || + getIndexTypeOfContextualType(type, 0); + } + return undefined; + } + function getContextualTypeForElementExpression(arrayContextualType, index) { + return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) + || getIteratedTypeOrElementType(1, arrayContextualType, undefinedType, undefined, false)); + } + function getContextualTypeForConditionalOperand(node, contextFlags) { + var conditional = node.parent; + return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined; + } + function getContextualTypeForChildJsxExpression(node, child) { + var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName); + var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) { + return undefined; + } + var realChildren = getSemanticJsxChildren(node.children); + var childIndex = realChildren.indexOf(child); + var childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName); + return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, function (t) { + if (isArrayLikeType(t)) { + return getIndexedAccessType(t, getLiteralType(childIndex)); + } + else { + return t; + } + }, true)); + } + function getContextualTypeForJsxExpression(node) { + var exprParent = node.parent; + return ts.isJsxAttributeLike(exprParent) + ? getContextualType(node) + : ts.isJsxElement(exprParent) + ? getContextualTypeForChildJsxExpression(exprParent, node) + : undefined; + } + function getContextualTypeForJsxAttribute(attribute) { + if (ts.isJsxAttribute(attribute)) { + var attributesType = getApparentTypeOfContextualType(attribute.parent); + if (!attributesType || isTypeAny(attributesType)) { + return undefined; + } + return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText); + } + else { + return getContextualType(attribute.parent); + } + } + function isPossiblyDiscriminantValue(node) { + switch (node.kind) { + case 10: + case 8: + case 9: + case 14: + case 106: + case 91: + case 100: + case 75: + case 146: + return true; + case 194: + case 200: + return isPossiblyDiscriminantValue(node.expression); + case 276: + return !node.expression || isPossiblyDiscriminantValue(node.expression); + } + return false; + } + function discriminateContextualTypeByObjectMembers(node, contextualType) { + return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 281 && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return checkExpression(prop.initializer); }, prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType); + } + function discriminateContextualTypeByJSXAttributes(node, contextualType) { + return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 273 && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return checkExpression(prop.initializer); }), prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType); + } + function getApparentTypeOfContextualType(node, contextFlags) { + var contextualType = ts.isObjectLiteralMethod(node) ? + getContextualTypeForObjectLiteralMethod(node, contextFlags) : + getContextualType(node, contextFlags); + var instantiatedType = instantiateContextualType(contextualType, node, contextFlags); + if (instantiatedType && !(contextFlags && contextFlags & 2 && instantiatedType.flags & 8650752)) { + var apparentType = mapType(instantiatedType, getApparentType, true); + if (apparentType.flags & 1048576) { + if (ts.isObjectLiteralExpression(node)) { + return discriminateContextualTypeByObjectMembers(node, apparentType); + } + else if (ts.isJsxAttributes(node)) { + return discriminateContextualTypeByJSXAttributes(node, apparentType); + } + } + return apparentType; + } + } + function instantiateContextualType(contextualType, node, contextFlags) { + if (contextualType && maybeTypeOfKind(contextualType, 63176704)) { + var inferenceContext = getInferenceContext(node); + if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) { + if (contextFlags && contextFlags & 1) { + return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper); + } + if (inferenceContext.returnMapper) { + return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper); + } + } + } + return contextualType; + } + function instantiateInstantiableTypes(type, mapper) { + if (type.flags & 63176704) { + return instantiateType(type, mapper); + } + if (type.flags & 1048576) { + return getUnionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }), 0); + } + if (type.flags & 2097152) { + return getIntersectionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); })); + } + return type; + } + function getContextualType(node, contextFlags) { + if (node.flags & 16777216) { + return undefined; + } + if (node.contextualType) { + return node.contextualType; + } + var parent = node.parent; + switch (parent.kind) { + case 242: + case 156: + case 159: + case 158: + case 191: + return getContextualTypeForInitializerExpression(node); + case 202: + case 235: + return getContextualTypeForReturnExpression(node); + case 212: + return getContextualTypeForYieldOperand(parent); + case 206: + return getContextualTypeForAwaitOperand(parent); + case 196: + if (parent.expression.kind === 96) { + return stringType; + } + case 197: + return getContextualTypeForArgument(parent, node); + case 199: + case 217: + return ts.isConstTypeReference(parent.type) ? undefined : getTypeFromTypeNode(parent.type); + case 209: + return getContextualTypeForBinaryOperand(node, contextFlags); + case 281: + case 282: + return getContextualTypeForObjectLiteralElement(parent, contextFlags); + case 283: + return getApparentTypeOfContextualType(parent.parent, contextFlags); + case 192: { + var arrayLiteral = parent; + var type = getApparentTypeOfContextualType(arrayLiteral, contextFlags); + return getContextualTypeForElementExpression(type, ts.indexOfNode(arrayLiteral.elements, node)); + } + case 210: + return getContextualTypeForConditionalOperand(node, contextFlags); + case 221: + ts.Debug.assert(parent.parent.kind === 211); + return getContextualTypeForSubstitutionExpression(parent.parent, node); + case 200: { + var tag = ts.isInJSFile(parent) ? ts.getJSDocTypeTag(parent) : undefined; + return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(parent, contextFlags); + } + case 276: + return getContextualTypeForJsxExpression(parent); + case 273: + case 275: + return getContextualTypeForJsxAttribute(parent); + case 268: + case 267: + return getContextualJsxElementAttributesType(parent, contextFlags); + } + return undefined; + } + function getInferenceContext(node) { + var ancestor = ts.findAncestor(node, function (n) { return !!n.inferenceContext; }); + return ancestor && ancestor.inferenceContext; + } + function getContextualJsxElementAttributesType(node, contextFlags) { + if (ts.isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4) { + return node.parent.contextualType; + } + return getContextualTypeForArgumentAtIndex(node, 0); + } + function getEffectiveFirstArgumentForJsxSignature(signature, node) { + return getJsxReferenceKind(node) !== 0 + ? getJsxPropsTypeFromCallSignature(signature, node) + : getJsxPropsTypeFromClassType(signature, node); + } + function getJsxPropsTypeFromCallSignature(sig, context) { + var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType); + propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType); + var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context); + if (intrinsicAttribs !== errorType) { + propsType = intersectTypes(intrinsicAttribs, propsType); + } + return propsType; + } + function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) { + if (sig.unionSignatures) { + var results = []; + for (var _i = 0, _a = sig.unionSignatures; _i < _a.length; _i++) { + var signature = _a[_i]; + var instance = getReturnTypeOfSignature(signature); + if (isTypeAny(instance)) { + return instance; + } + var propType = getTypeOfPropertyOfType(instance, forcedLookupLocation); + if (!propType) { + return; + } + results.push(propType); + } + return getIntersectionType(results); + } + var instanceType = getReturnTypeOfSignature(sig); + return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation); + } + function getStaticTypeOfReferencedJsxConstructor(context) { + if (isJsxIntrinsicIdentifier(context.tagName)) { + var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context); + var fakeSignature = createSignatureForJSXIntrinsic(context, result); + return getOrCreateTypeFromSignature(fakeSignature); + } + var tagType = checkExpressionCached(context.tagName); + if (tagType.flags & 128) { + var result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context); + if (!result) { + return errorType; + } + var fakeSignature = createSignatureForJSXIntrinsic(context, result); + return getOrCreateTypeFromSignature(fakeSignature); + } + return tagType; + } + function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) { + var managedSym = getJsxLibraryManagedAttributes(ns); + if (managedSym) { + var declaredManagedType = getDeclaredTypeOfSymbol(managedSym); + var ctorType = getStaticTypeOfReferencedJsxConstructor(context); + if (ts.length(declaredManagedType.typeParameters) >= 2) { + var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, ts.isInJSFile(context)); + return createTypeReference(declaredManagedType, args); + } + else if (ts.length(declaredManagedType.aliasTypeArguments) >= 2) { + var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments, 2, ts.isInJSFile(context)); + return getTypeAliasInstantiation(declaredManagedType.aliasSymbol, args); + } + } + return attributesType; + } + function getJsxPropsTypeFromClassType(sig, context) { + var ns = getJsxNamespaceAt(context); + var forcedLookupLocation = getJsxElementPropertiesName(ns); + var attributesType = forcedLookupLocation === undefined + ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType) + : forcedLookupLocation === "" + ? getReturnTypeOfSignature(sig) + : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation); + if (!attributesType) { + if (!!forcedLookupLocation && !!ts.length(context.attributes.properties)) { + error(context, ts.Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, ts.unescapeLeadingUnderscores(forcedLookupLocation)); + } + return unknownType; + } + attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType); + if (isTypeAny(attributesType)) { + return attributesType; + } + else { + var apparentAttributesType = attributesType; + var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context); + if (intrinsicClassAttribs !== errorType) { + var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol); + var hostClassType = getReturnTypeOfSignature(sig); + apparentAttributesType = intersectTypes(typeParams + ? createTypeReference(intrinsicClassAttribs, fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), ts.isInJSFile(context))) + : intrinsicClassAttribs, apparentAttributesType); + } + var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context); + if (intrinsicAttribs !== errorType) { + apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType); + } + return apparentAttributesType; + } + } + function getContextualCallSignature(type, node) { + var signatures = getSignaturesOfType(type, 0); + if (signatures.length === 1) { + var signature = signatures[0]; + if (!isAritySmaller(signature, node)) { + return signature; + } + } + } + function isAritySmaller(signature, target) { + var targetParameterCount = 0; + for (; targetParameterCount < target.parameters.length; targetParameterCount++) { + var param = target.parameters[targetParameterCount]; + if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) { + break; + } + } + if (target.parameters.length && ts.parameterIsThisKeyword(target.parameters[0])) { + targetParameterCount--; + } + return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount; + } + function isFunctionExpressionOrArrowFunction(node) { + return node.kind === 201 || node.kind === 202; + } + function getContextualSignatureForFunctionLikeDeclaration(node) { + return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node) + ? getContextualSignature(node) + : undefined; + } + function getContextualSignature(node) { + ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node)); + var typeTagSignature = getSignatureOfTypeTag(node); + if (typeTagSignature) { + return typeTagSignature; + } + var type = getApparentTypeOfContextualType(node, 1); + if (!type) { + return undefined; + } + if (!(type.flags & 1048576)) { + return getContextualCallSignature(type, node); + } + var signatureList; + var types = type.types; + for (var _i = 0, types_16 = types; _i < types_16.length; _i++) { + var current = types_16[_i]; + var signature = getContextualCallSignature(current, node); + if (signature) { + if (!signatureList) { + signatureList = [signature]; + } + else if (!compareSignaturesIdentical(signatureList[0], signature, false, true, true, compareTypesIdentical)) { + return undefined; + } + else { + signatureList.push(signature); + } + } + } + if (signatureList) { + return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList); + } + } + function checkSpreadExpression(node, checkMode) { + if (languageVersion < 2) { + checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 : 2048); + } + var arrayOrIterableType = checkExpression(node.expression, checkMode); + return checkIteratedTypeOrElementType(33, arrayOrIterableType, undefinedType, node.expression); + } + function hasDefaultValue(node) { + return (node.kind === 191 && !!node.initializer) || + (node.kind === 209 && node.operatorToken.kind === 62); + } + function checkArrayLiteral(node, checkMode, forceTuple) { + var elements = node.elements; + var elementCount = elements.length; + var hasNonEndingSpreadElement = false; + var elementTypes = []; + var inDestructuringPattern = ts.isAssignmentTarget(node); + var contextualType = getApparentTypeOfContextualType(node); + var inConstContext = isConstContext(node); + for (var index = 0; index < elementCount; index++) { + var e = elements[index]; + if (inDestructuringPattern && e.kind === 213) { + var restArrayType = checkExpression(e.expression, checkMode, forceTuple); + var restElementType = getIndexTypeOfType(restArrayType, 1) || + getIteratedTypeOrElementType(65, restArrayType, undefinedType, undefined, false); + if (restElementType) { + elementTypes.push(restElementType); + } + } + else { + var elementContextualType = getContextualTypeForElementExpression(contextualType, index); + var type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple); + elementTypes.push(type); + } + if (index < elementCount - 1 && e.kind === 213) { + hasNonEndingSpreadElement = true; + } + } + if (!hasNonEndingSpreadElement) { + var hasRestElement = elementCount > 0 && elements[elementCount - 1].kind === 213; + var minLength = elementCount - (hasRestElement ? 1 : 0); + var tupleResult = void 0; + if (inDestructuringPattern && minLength > 0) { + var type = cloneTypeReference(createTupleType(elementTypes, minLength, hasRestElement)); + type.pattern = node; + return type; + } + else if (tupleResult = getArrayLiteralTupleTypeIfApplicable(elementTypes, contextualType, hasRestElement, elementCount, inConstContext)) { + return createArrayLiteralType(tupleResult); + } + else if (forceTuple) { + return createArrayLiteralType(createTupleType(elementTypes, minLength, hasRestElement)); + } + } + return createArrayLiteralType(createArrayType(elementTypes.length ? + getUnionType(elementTypes, 2) : + strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext)); + } + function createArrayLiteralType(type) { + if (!(ts.getObjectFlags(type) & 4)) { + return type; + } + var literalType = type.literalType; + if (!literalType) { + literalType = type.literalType = cloneTypeReference(type); + literalType.objectFlags |= 65536 | 1048576; + } + return literalType; + } + function getArrayLiteralTupleTypeIfApplicable(elementTypes, contextualType, hasRestElement, elementCount, readonly) { + if (elementCount === void 0) { elementCount = elementTypes.length; } + if (readonly === void 0) { readonly = false; } + if (readonly || (contextualType && forEachType(contextualType, isTupleLikeType))) { + return createTupleType(elementTypes, elementCount - (hasRestElement ? 1 : 0), hasRestElement, readonly); + } + } + function isNumericName(name) { + switch (name.kind) { + case 154: + return isNumericComputedName(name); + case 75: + return isNumericLiteralName(name.escapedText); + case 8: + case 10: + return isNumericLiteralName(name.text); + default: + return false; + } + } + function isNumericComputedName(name) { + return isTypeAssignableToKind(checkComputedPropertyName(name), 296); + } + function isInfinityOrNaNString(name) { + return name === "Infinity" || name === "-Infinity" || name === "NaN"; + } + function isNumericLiteralName(name) { + return (+name).toString() === name; + } + function checkComputedPropertyName(node) { + var links = getNodeLinks(node.expression); + if (!links.resolvedType) { + links.resolvedType = checkExpression(node.expression); + if (links.resolvedType.flags & 98304 || + !isTypeAssignableToKind(links.resolvedType, 132 | 296 | 12288) && + !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) { + error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any); + } + else { + checkThatExpressionIsProperSymbolReference(node.expression, links.resolvedType, true); + } + } + return links.resolvedType; + } + function getObjectLiteralIndexInfo(node, offset, properties, kind) { + var propTypes = []; + for (var i = 0; i < properties.length; i++) { + if (kind === 0 || isNumericName(node.properties[i + offset].name)) { + propTypes.push(getTypeOfSymbol(properties[i])); + } + } + var unionType = propTypes.length ? getUnionType(propTypes, 2) : undefinedType; + return createIndexInfo(unionType, isConstContext(node)); + } + function getImmediateAliasedSymbol(symbol) { + ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here."); + var links = getSymbolLinks(symbol); + if (!links.immediateTarget) { + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + links.immediateTarget = getTargetOfAliasDeclaration(node, true); + } + return links.immediateTarget; + } + function checkObjectLiteral(node, checkMode) { + var inDestructuringPattern = ts.isAssignmentTarget(node); + checkGrammarObjectLiteralExpression(node, inDestructuringPattern); + var propertiesTable; + var propertiesArray = []; + var spread = emptyObjectType; + var contextualType = getApparentTypeOfContextualType(node); + var contextualTypeHasPattern = contextualType && contextualType.pattern && + (contextualType.pattern.kind === 189 || contextualType.pattern.kind === 193); + var inConstContext = isConstContext(node); + var checkFlags = inConstContext ? 8 : 0; + var isInJavascript = ts.isInJSFile(node) && !ts.isInJsonFile(node); + var enumTag = ts.getJSDocEnumTag(node); + var isJSObjectLiteral = !contextualType && isInJavascript && !enumTag; + var objectFlags = freshObjectLiteralFlag; + var patternWithComputedProperties = false; + var hasComputedStringProperty = false; + var hasComputedNumberProperty = false; + propertiesTable = ts.createSymbolTable(); + var offset = 0; + for (var i = 0; i < node.properties.length; i++) { + var memberDecl = node.properties[i]; + var member = getSymbolOfNode(memberDecl); + var computedNameType = memberDecl.name && memberDecl.name.kind === 154 && !ts.isWellKnownSymbolSyntactically(memberDecl.name.expression) ? + checkComputedPropertyName(memberDecl.name) : undefined; + if (memberDecl.kind === 281 || + memberDecl.kind === 282 || + ts.isObjectLiteralMethod(memberDecl)) { + var type = memberDecl.kind === 281 ? checkPropertyAssignment(memberDecl, checkMode) : + memberDecl.kind === 282 ? checkExpressionForMutableLocation(memberDecl.name, checkMode) : + checkObjectLiteralMethod(memberDecl, checkMode); + if (isInJavascript) { + var jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl); + if (jsDocType) { + checkTypeAssignableTo(type, jsDocType, memberDecl); + type = jsDocType; + } + else if (enumTag && enumTag.typeExpression) { + checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl); + } + } + objectFlags |= ts.getObjectFlags(type) & 3670016; + var nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined; + var prop = nameType ? + createSymbol(4 | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096) : + createSymbol(4 | member.flags, member.escapedName, checkFlags); + if (nameType) { + prop.nameType = nameType; + } + if (inDestructuringPattern) { + var isOptional = (memberDecl.kind === 281 && hasDefaultValue(memberDecl.initializer)) || + (memberDecl.kind === 282 && memberDecl.objectAssignmentInitializer); + if (isOptional) { + prop.flags |= 16777216; + } + } + else if (contextualTypeHasPattern && !(ts.getObjectFlags(contextualType) & 512)) { + var impliedProp = getPropertyOfType(contextualType, member.escapedName); + if (impliedProp) { + prop.flags |= impliedProp.flags & 16777216; + } + else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, 0)) { + error(memberDecl.name, ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(member), typeToString(contextualType)); + } + } + prop.declarations = member.declarations; + prop.parent = member.parent; + if (member.valueDeclaration) { + prop.valueDeclaration = member.valueDeclaration; + } + prop.type = type; + prop.target = member; + member = prop; + } + else if (memberDecl.kind === 283) { + if (languageVersion < 2) { + checkExternalEmitHelpers(memberDecl, 2); + } + if (propertiesArray.length > 0) { + spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext); + propertiesArray = []; + propertiesTable = ts.createSymbolTable(); + hasComputedStringProperty = false; + hasComputedNumberProperty = false; + } + var type = checkExpression(memberDecl.expression); + if (!isValidSpreadType(type)) { + error(memberDecl, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types); + return errorType; + } + spread = getSpreadType(spread, type, node.symbol, objectFlags, inConstContext); + offset = i + 1; + continue; + } + else { + ts.Debug.assert(memberDecl.kind === 163 || memberDecl.kind === 164); + checkNodeDeferred(memberDecl); + } + if (computedNameType && !(computedNameType.flags & 8576)) { + if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) { + if (isTypeAssignableTo(computedNameType, numberType)) { + hasComputedNumberProperty = true; + } + else { + hasComputedStringProperty = true; + } + if (inDestructuringPattern) { + patternWithComputedProperties = true; + } + } + } + else { + propertiesTable.set(member.escapedName, member); + } + propertiesArray.push(member); + } + if (contextualTypeHasPattern) { + for (var _i = 0, _a = getPropertiesOfType(contextualType); _i < _a.length; _i++) { + var prop = _a[_i]; + if (!propertiesTable.get(prop.escapedName) && !(spread && getPropertyOfType(spread, prop.escapedName))) { + if (!(prop.flags & 16777216)) { + error(prop.valueDeclaration || prop.bindingElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value); + } + propertiesTable.set(prop.escapedName, prop); + propertiesArray.push(prop); + } + } + } + if (spread !== emptyObjectType) { + if (propertiesArray.length > 0) { + spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext); + propertiesArray = []; + propertiesTable = ts.createSymbolTable(); + hasComputedStringProperty = false; + hasComputedNumberProperty = false; + } + return mapType(spread, function (t) { return t === emptyObjectType ? createObjectLiteralType() : t; }); + } + return createObjectLiteralType(); + function createObjectLiteralType() { + var stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 0) : undefined; + var numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 1) : undefined; + var result = createAnonymousType(node.symbol, propertiesTable, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo); + result.objectFlags |= objectFlags | 128 | 1048576; + if (isJSObjectLiteral) { + result.objectFlags |= 16384; + } + if (patternWithComputedProperties) { + result.objectFlags |= 512; + } + if (inDestructuringPattern) { + result.pattern = node; + } + return result; + } + } + function isValidSpreadType(type) { + if (type.flags & 63176704) { + var constraint = getBaseConstraintOfType(type); + if (constraint !== undefined) { + return isValidSpreadType(constraint); + } + } + return !!(type.flags & (1 | 67108864 | 524288 | 58982400) || + getFalsyFlags(type) & 117632 && isValidSpreadType(removeDefinitelyFalsyTypes(type)) || + type.flags & 3145728 && ts.every(type.types, isValidSpreadType)); + } + function checkJsxSelfClosingElementDeferred(node) { + checkJsxOpeningLikeElementOrOpeningFragment(node); + } + function checkJsxSelfClosingElement(node, _checkMode) { + checkNodeDeferred(node); + return getJsxElementTypeAt(node) || anyType; + } + function checkJsxElementDeferred(node) { + checkJsxOpeningLikeElementOrOpeningFragment(node.openingElement); + if (isJsxIntrinsicIdentifier(node.closingElement.tagName)) { + getIntrinsicTagSymbol(node.closingElement); + } + else { + checkExpression(node.closingElement.tagName); + } + checkJsxChildren(node); + } + function checkJsxElement(node, _checkMode) { + checkNodeDeferred(node); + return getJsxElementTypeAt(node) || anyType; + } + function checkJsxFragment(node) { + checkJsxOpeningLikeElementOrOpeningFragment(node.openingFragment); + if (compilerOptions.jsx === 2 && (compilerOptions.jsxFactory || ts.getSourceFileOfNode(node).pragmas.has("jsx"))) { + error(node, compilerOptions.jsxFactory + ? ts.Diagnostics.JSX_fragment_is_not_supported_when_using_jsxFactory + : ts.Diagnostics.JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma); + } + checkJsxChildren(node); + return getJsxElementTypeAt(node) || anyType; + } + function isUnhyphenatedJsxName(name) { + return !ts.stringContains(name, "-"); + } + function isJsxIntrinsicIdentifier(tagName) { + return tagName.kind === 75 && ts.isIntrinsicJsxName(tagName.escapedText); + } + function checkJsxAttribute(node, checkMode) { + return node.initializer + ? checkExpressionForMutableLocation(node.initializer, checkMode) + : trueType; + } + function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) { + var attributes = openingLikeElement.attributes; + var attributesTable = ts.createSymbolTable(); + var spread = emptyJsxObjectType; + var hasSpreadAnyType = false; + var typeToIntersect; + var explicitlySpecifyChildrenAttribute = false; + var objectFlags = 4096; + var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement)); + for (var _i = 0, _a = attributes.properties; _i < _a.length; _i++) { + var attributeDecl = _a[_i]; + var member = attributeDecl.symbol; + if (ts.isJsxAttribute(attributeDecl)) { + var exprType = checkJsxAttribute(attributeDecl, checkMode); + objectFlags |= ts.getObjectFlags(exprType) & 3670016; + var attributeSymbol = createSymbol(4 | 33554432 | member.flags, member.escapedName); + attributeSymbol.declarations = member.declarations; + attributeSymbol.parent = member.parent; + if (member.valueDeclaration) { + attributeSymbol.valueDeclaration = member.valueDeclaration; + } + attributeSymbol.type = exprType; + attributeSymbol.target = member; + attributesTable.set(attributeSymbol.escapedName, attributeSymbol); + if (attributeDecl.name.escapedText === jsxChildrenPropertyName) { + explicitlySpecifyChildrenAttribute = true; + } + } + else { + ts.Debug.assert(attributeDecl.kind === 275); + if (attributesTable.size > 0) { + spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false); + attributesTable = ts.createSymbolTable(); + } + var exprType = checkExpressionCached(attributeDecl.expression, checkMode); + if (isTypeAny(exprType)) { + hasSpreadAnyType = true; + } + if (isValidSpreadType(exprType)) { + spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, false); + } + else { + typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType; + } + } + } + if (!hasSpreadAnyType) { + if (attributesTable.size > 0) { + spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false); + } + } + var parent = openingLikeElement.parent.kind === 266 ? openingLikeElement.parent : undefined; + if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) { + var childrenTypes = checkJsxChildren(parent, checkMode); + if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") { + if (explicitlySpecifyChildrenAttribute) { + error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName)); + } + var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes); + var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName); + var childrenPropSymbol = createSymbol(4 | 33554432, jsxChildrenPropertyName); + childrenPropSymbol.type = childrenTypes.length === 1 ? + childrenTypes[0] : + (getArrayLiteralTupleTypeIfApplicable(childrenTypes, childrenContextualType, false) || createArrayType(getUnionType(childrenTypes))); + childrenPropSymbol.valueDeclaration = ts.createPropertySignature(undefined, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName), undefined, undefined, undefined); + childrenPropSymbol.valueDeclaration.parent = attributes; + childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol; + var childPropMap = ts.createSymbolTable(); + childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol); + spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, ts.emptyArray, ts.emptyArray, undefined, undefined), attributes.symbol, objectFlags, false); + } + } + if (hasSpreadAnyType) { + return anyType; + } + if (typeToIntersect && spread !== emptyJsxObjectType) { + return getIntersectionType([typeToIntersect, spread]); + } + return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread); + function createJsxAttributesType() { + objectFlags |= freshObjectLiteralFlag; + var result = createAnonymousType(attributes.symbol, attributesTable, ts.emptyArray, ts.emptyArray, undefined, undefined); + result.objectFlags |= objectFlags | 128 | 1048576; + return result; + } + } + function checkJsxChildren(node, checkMode) { + var childrenTypes = []; + for (var _i = 0, _a = node.children; _i < _a.length; _i++) { + var child = _a[_i]; + if (child.kind === 11) { + if (!child.containsOnlyTriviaWhiteSpaces) { + childrenTypes.push(stringType); + } + } + else { + childrenTypes.push(checkExpressionForMutableLocation(child, checkMode)); + } + } + return childrenTypes; + } + function checkJsxAttributes(node, checkMode) { + return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode); + } + function getJsxType(name, location) { + var namespace = getJsxNamespaceAt(location); + var exports = namespace && getExportsOfSymbol(namespace); + var typeSymbol = exports && getSymbol(exports, name, 788968); + return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType; + } + function getIntrinsicTagSymbol(node) { + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node); + if (intrinsicElementsType !== errorType) { + if (!ts.isIdentifier(node.tagName)) + return ts.Debug.fail(); + var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText); + if (intrinsicProp) { + links.jsxFlags |= 1; + return links.resolvedSymbol = intrinsicProp; + } + var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0); + if (indexSignatureType) { + links.jsxFlags |= 2; + return links.resolvedSymbol = intrinsicElementsType.symbol; + } + error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.idText(node.tagName), "JSX." + JsxNames.IntrinsicElements); + return links.resolvedSymbol = unknownSymbol; + } + else { + if (noImplicitAny) { + error(node, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, ts.unescapeLeadingUnderscores(JsxNames.IntrinsicElements)); + } + return links.resolvedSymbol = unknownSymbol; + } + } + return links.resolvedSymbol; + } + function getJsxNamespaceAt(location) { + var links = location && getNodeLinks(location); + if (links && links.jsxNamespace) { + return links.jsxNamespace; + } + if (!links || links.jsxNamespace !== false) { + var namespaceName = getJsxNamespace(location); + var resolvedNamespace = resolveName(location, namespaceName, 1920, undefined, namespaceName, false); + if (resolvedNamespace) { + var candidate = resolveSymbol(getSymbol(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920)); + if (candidate) { + if (links) { + links.jsxNamespace = candidate; + } + return candidate; + } + if (links) { + links.jsxNamespace = false; + } + } + } + return getGlobalSymbol(JsxNames.JSX, 1920, undefined); + } + function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) { + var jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol(jsxNamespace.exports, nameOfAttribPropContainer, 788968); + var jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym); + var propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType); + if (propertiesOfJsxElementAttribPropInterface) { + if (propertiesOfJsxElementAttribPropInterface.length === 0) { + return ""; + } + else if (propertiesOfJsxElementAttribPropInterface.length === 1) { + return propertiesOfJsxElementAttribPropInterface[0].escapedName; + } + else if (propertiesOfJsxElementAttribPropInterface.length > 1) { + error(jsxElementAttribPropInterfaceSym.declarations[0], ts.Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, ts.unescapeLeadingUnderscores(nameOfAttribPropContainer)); + } + } + return undefined; + } + function getJsxLibraryManagedAttributes(jsxNamespace) { + return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968); + } + function getJsxElementPropertiesName(jsxNamespace) { + return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace); + } + function getJsxElementChildrenPropertyName(jsxNamespace) { + return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace); + } + function getUninstantiatedJsxSignaturesOfType(elementType, caller) { + if (elementType.flags & 4) { + return [anySignature]; + } + else if (elementType.flags & 128) { + var intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller); + if (!intrinsicType) { + error(caller, ts.Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements); + return ts.emptyArray; + } + else { + var fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType); + return [fakeSignature]; + } + } + var apparentElemType = getApparentType(elementType); + var signatures = getSignaturesOfType(apparentElemType, 1); + if (signatures.length === 0) { + signatures = getSignaturesOfType(apparentElemType, 0); + } + if (signatures.length === 0 && apparentElemType.flags & 1048576) { + signatures = getUnionSignatures(ts.map(apparentElemType.types, function (t) { return getUninstantiatedJsxSignaturesOfType(t, caller); })); + } + return signatures; + } + function getIntrinsicAttributesTypeFromStringLiteralType(type, location) { + var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location); + if (intrinsicElementsType !== errorType) { + var stringLiteralTypeName = type.value; + var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName)); + if (intrinsicProp) { + return getTypeOfSymbol(intrinsicProp); + } + var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0); + if (indexSignatureType) { + return indexSignatureType; + } + return undefined; + } + return anyType; + } + function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) { + if (refKind === 1) { + var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement); + if (sfcReturnConstraint) { + checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement, ts.Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); + } + } + else if (refKind === 0) { + var classConstraint = getJsxElementClassTypeAt(openingLikeElement); + if (classConstraint) { + checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement, ts.Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); + } + } + else { + var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement); + var classConstraint = getJsxElementClassTypeAt(openingLikeElement); + if (!sfcReturnConstraint || !classConstraint) { + return; + } + var combined = getUnionType([sfcReturnConstraint, classConstraint]); + checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement, ts.Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); + } + } + function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) { + ts.Debug.assert(isJsxIntrinsicIdentifier(node.tagName)); + var links = getNodeLinks(node); + if (!links.resolvedJsxElementAttributesType) { + var symbol = getIntrinsicTagSymbol(node); + if (links.jsxFlags & 1) { + return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol); + } + else if (links.jsxFlags & 2) { + return links.resolvedJsxElementAttributesType = + getIndexTypeOfType(getDeclaredTypeOfSymbol(symbol), 0); + } + else { + return links.resolvedJsxElementAttributesType = errorType; + } + } + return links.resolvedJsxElementAttributesType; + } + function getJsxElementClassTypeAt(location) { + var type = getJsxType(JsxNames.ElementClass, location); + if (type === errorType) + return undefined; + return type; + } + function getJsxElementTypeAt(location) { + return getJsxType(JsxNames.Element, location); + } + function getJsxStatelessElementTypeAt(location) { + var jsxElementType = getJsxElementTypeAt(location); + if (jsxElementType) { + return getUnionType([jsxElementType, nullType]); + } + } + function getJsxIntrinsicTagNamesAt(location) { + var intrinsics = getJsxType(JsxNames.IntrinsicElements, location); + return intrinsics ? getPropertiesOfType(intrinsics) : ts.emptyArray; + } + function checkJsxPreconditions(errorNode) { + if ((compilerOptions.jsx || 0) === 0) { + error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided); + } + if (getJsxElementTypeAt(errorNode) === undefined) { + if (noImplicitAny) { + error(errorNode, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); + } + } + } + function checkJsxOpeningLikeElementOrOpeningFragment(node) { + var isNodeOpeningLikeElement = ts.isJsxOpeningLikeElement(node); + if (isNodeOpeningLikeElement) { + checkGrammarJsxElement(node); + } + checkJsxPreconditions(node); + var reactRefErr = diagnostics && compilerOptions.jsx === 2 ? ts.Diagnostics.Cannot_find_name_0 : undefined; + var reactNamespace = getJsxNamespace(node); + var reactLocation = isNodeOpeningLikeElement ? node.tagName : node; + var reactSym = resolveName(reactLocation, reactNamespace, 111551, reactRefErr, reactNamespace, true); + if (reactSym) { + reactSym.isReferenced = 67108863; + if (reactSym.flags & 2097152 && !getTypeOnlyAliasDeclaration(reactSym)) { + markAliasSymbolAsReferenced(reactSym); + } + } + if (isNodeOpeningLikeElement) { + var sig = getResolvedSignature(node); + checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(node), getReturnTypeOfSignature(sig), node); + } + } + function isKnownProperty(targetType, name, isComparingJsxAttributes) { + if (targetType.flags & 524288) { + var resolved = resolveStructuredTypeMembers(targetType); + if (resolved.stringIndexInfo || + resolved.numberIndexInfo && isNumericLiteralName(name) || + getPropertyOfObjectType(targetType, name) || + isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) { + return true; + } + } + else if (targetType.flags & 3145728 && isExcessPropertyCheckTarget(targetType)) { + for (var _i = 0, _a = targetType.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (isKnownProperty(t, name, isComparingJsxAttributes)) { + return true; + } + } + } + return false; + } + function isExcessPropertyCheckTarget(type) { + return !!(type.flags & 524288 && !(ts.getObjectFlags(type) & 512) || + type.flags & 67108864 || + type.flags & 1048576 && ts.some(type.types, isExcessPropertyCheckTarget) || + type.flags & 2097152 && ts.every(type.types, isExcessPropertyCheckTarget)); + } + function checkJsxExpression(node, checkMode) { + checkGrammarJsxExpression(node); + if (node.expression) { + var type = checkExpression(node.expression, checkMode); + if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) { + error(node, ts.Diagnostics.JSX_spread_child_must_be_an_array_type); + } + return type; + } + else { + return errorType; + } + } + function getDeclarationNodeFlagsFromSymbol(s) { + return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : 0; + } + function isPrototypeProperty(symbol) { + if (symbol.flags & 8192 || ts.getCheckFlags(symbol) & 4) { + return true; + } + if (ts.isInJSFile(symbol.valueDeclaration)) { + var parent = symbol.valueDeclaration.parent; + return parent && ts.isBinaryExpression(parent) && + ts.getAssignmentDeclarationKind(parent) === 3; + } + } + function checkPropertyAccessibility(node, isSuper, type, prop) { + var flags = ts.getDeclarationModifierFlagsFromSymbol(prop); + var errorNode = node.kind === 153 ? node.right : node.kind === 188 ? node : node.name; + if (ts.getCheckFlags(prop) & 1024) { + error(errorNode, ts.Diagnostics.Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1, symbolToString(prop), typeToString(type)); + return false; + } + if (isSuper) { + if (languageVersion < 2) { + if (symbolHasNonMethodDeclaration(prop)) { + error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + return false; + } + } + if (flags & 128) { + error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(getDeclaringClass(prop))); + return false; + } + } + if ((flags & 128) && ts.isThisProperty(node) && symbolHasNonMethodDeclaration(prop)) { + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop)); + if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(node)) { + error(errorNode, ts.Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, symbolToString(prop), ts.getTextOfIdentifierOrLiteral(declaringClassDeclaration.name)); + return false; + } + } + if (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name)) { + if (!ts.getContainingClass(node)) { + error(errorNode, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + return false; + } + return true; + } + if (!(flags & 24)) { + return true; + } + if (flags & 8) { + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop)); + if (!isNodeWithinClass(node, declaringClassDeclaration)) { + error(errorNode, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(getDeclaringClass(prop))); + return false; + } + return true; + } + if (isSuper) { + return true; + } + var enclosingClass = forEachEnclosingClass(node, function (enclosingDeclaration) { + var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration)); + return isClassDerivedFromDeclaringClasses(enclosingClass, prop) ? enclosingClass : undefined; + }); + if (!enclosingClass) { + var thisParameter = void 0; + if (flags & 32 || !(thisParameter = getThisParameterFromNodeContext(node)) || !thisParameter.type) { + error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || type)); + return false; + } + var thisType = getTypeFromTypeNode(thisParameter.type); + enclosingClass = ((thisType.flags & 262144) ? getConstraintOfTypeParameter(thisType) : thisType); + } + if (flags & 32) { + return true; + } + if (type.flags & 262144) { + type = type.isThisType ? getConstraintOfTypeParameter(type) : getBaseConstraintOfType(type); + } + if (!type || !hasBaseType(type, enclosingClass)) { + error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass)); + return false; + } + return true; + } + function getThisParameterFromNodeContext(node) { + var thisContainer = ts.getThisContainer(node, false); + return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined; + } + function symbolHasNonMethodDeclaration(symbol) { + return !!forEachProperty(symbol, function (prop) { return !(prop.flags & 8192); }); + } + function checkNonNullExpression(node) { + return checkNonNullType(checkExpression(node), node); + } + function isNullableType(type) { + return !!((strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304); + } + function getNonNullableTypeIfNeeded(type) { + return isNullableType(type) ? getNonNullableType(type) : type; + } + function reportObjectPossiblyNullOrUndefinedError(node, flags) { + error(node, flags & 32768 ? flags & 65536 ? + ts.Diagnostics.Object_is_possibly_null_or_undefined : + ts.Diagnostics.Object_is_possibly_undefined : + ts.Diagnostics.Object_is_possibly_null); + } + function reportCannotInvokePossiblyNullOrUndefinedError(node, flags) { + error(node, flags & 32768 ? flags & 65536 ? + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined : + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined : + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null); + } + function checkNonNullTypeWithReporter(type, node, reportError) { + if (strictNullChecks && type.flags & 2) { + error(node, ts.Diagnostics.Object_is_of_type_unknown); + return errorType; + } + var kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304; + if (kind) { + reportError(node, kind); + var t = getNonNullableType(type); + return t.flags & (98304 | 131072) ? errorType : t; + } + return type; + } + function checkNonNullType(type, node) { + return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError); + } + function checkNonNullNonVoidType(type, node) { + var nonNullType = checkNonNullType(type, node); + if (nonNullType !== errorType && nonNullType.flags & 16384) { + error(node, ts.Diagnostics.Object_is_possibly_undefined); + } + return nonNullType; + } + function checkPropertyAccessExpression(node) { + return node.flags & 32 ? checkPropertyAccessChain(node) : + checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name); + } + function checkPropertyAccessChain(node) { + var leftType = checkExpression(node.expression); + var nonOptionalType = getOptionalExpressionType(leftType, node.expression); + return propagateOptionalTypeMarker(checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullType(nonOptionalType, node.expression), node.name), node, nonOptionalType !== leftType); + } + function checkQualifiedName(node) { + return checkPropertyAccessExpressionOrQualifiedName(node, node.left, checkNonNullExpression(node.left), node.right); + } + function isMethodAccessForCall(node) { + while (node.parent.kind === 200) { + node = node.parent; + } + return ts.isCallOrNewExpression(node.parent) && node.parent.expression === node; + } + function lookupSymbolForPrivateIdentifierDeclaration(propName, location) { + for (var containingClass = ts.getContainingClass(location); !!containingClass; containingClass = ts.getContainingClass(containingClass)) { + var symbol = containingClass.symbol; + var name = ts.getSymbolNameForPrivateIdentifier(symbol, propName); + var prop = (symbol.members && symbol.members.get(name)) || (symbol.exports && symbol.exports.get(name)); + if (prop) { + return prop; + } + } + } + function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) { + return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName); + } + function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) { + var propertyOnType; + var properties = getPropertiesOfType(leftType); + if (properties) { + ts.forEach(properties, function (symbol) { + var decl = symbol.valueDeclaration; + if (decl && ts.isNamedDeclaration(decl) && ts.isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) { + propertyOnType = symbol; + return true; + } + }); + } + var diagName = diagnosticName(right); + if (propertyOnType) { + var typeValueDecl = propertyOnType.valueDeclaration; + var typeClass_1 = ts.getContainingClass(typeValueDecl); + ts.Debug.assert(!!typeClass_1); + if (lexicallyScopedIdentifier) { + var lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration; + var lexicalClass = ts.getContainingClass(lexicalValueDecl); + ts.Debug.assert(!!lexicalClass); + if (ts.findAncestor(lexicalClass, function (n) { return typeClass_1 === n; })) { + var diagnostic = error(right, ts.Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling, diagName, typeToString(leftType)); + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(lexicalValueDecl, ts.Diagnostics.The_shadowing_declaration_of_0_is_defined_here, diagName), ts.createDiagnosticForNode(typeValueDecl, ts.Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here, diagName)); + return true; + } + } + error(right, ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier, diagName, diagnosticName(typeClass_1.name || anon)); + return true; + } + return false; + } + function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right) { + var parentSymbol = getNodeLinks(left).resolvedSymbol; + var assignmentKind = ts.getAssignmentTargetKind(node); + var apparentType = getApparentType(assignmentKind !== 0 || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType); + if (ts.isPrivateIdentifier(right)) { + checkExternalEmitHelpers(node, 262144); + } + var isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType; + var prop; + if (ts.isPrivateIdentifier(right)) { + var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right); + if (isAnyLike) { + if (lexicallyScopedSymbol) { + return apparentType; + } + if (!ts.getContainingClass(right)) { + grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + return anyType; + } + } + prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : undefined; + if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) { + return errorType; + } + } + else { + if (isAnyLike) { + if (ts.isIdentifier(left) && parentSymbol) { + markAliasReferenced(parentSymbol, node); + } + return apparentType; + } + prop = getPropertyOfType(apparentType, right.escapedText); + } + if (ts.isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) { + markAliasReferenced(parentSymbol, node); + } + var propType; + if (!prop) { + var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getIndexInfoOfType(apparentType, 0) : undefined; + if (!(indexInfo && indexInfo.type)) { + if (isJSLiteralType(leftType)) { + return anyType; + } + if (leftType.symbol === globalThisSymbol) { + if (globalThisSymbol.exports.has(right.escapedText) && (globalThisSymbol.exports.get(right.escapedText).flags & 418)) { + error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(right.escapedText), typeToString(leftType)); + } + else if (noImplicitAny) { + error(right, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType)); + } + return anyType; + } + if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) { + reportNonexistentProperty(right, isThisTypeParameter(leftType) ? apparentType : leftType); + } + return errorType; + } + if (indexInfo.isReadonly && (ts.isAssignmentTarget(node) || ts.isDeleteTarget(node))) { + error(node, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType)); + } + propType = indexInfo.type; + } + else { + checkPropertyNotUsedBeforeDeclaration(prop, node, right); + markPropertyAsReferenced(prop, node, left.kind === 104); + getNodeLinks(node).resolvedSymbol = prop; + checkPropertyAccessibility(node, left.kind === 102, apparentType, prop); + if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) { + error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right)); + return errorType; + } + propType = getConstraintForLocation(getTypeOfSymbol(prop), node); + } + return getFlowTypeOfAccessExpression(node, prop, propType, right); + } + function getFlowTypeOfAccessExpression(node, prop, propType, errorNode) { + var assignmentKind = ts.getAssignmentTargetKind(node); + if (!ts.isAccessExpression(node) || + assignmentKind === 1 || + prop && !(prop.flags & (3 | 4 | 98304)) && !(prop.flags & 8192 && propType.flags & 1048576)) { + return propType; + } + var assumeUninitialized = false; + if (strictNullChecks && strictPropertyInitialization && node.expression.kind === 104) { + var declaration = prop && prop.valueDeclaration; + if (declaration && isInstancePropertyWithoutInitializer(declaration)) { + var flowContainer = getControlFlowContainer(node); + if (flowContainer.kind === 162 && flowContainer.parent === declaration.parent && !(declaration.flags & 8388608)) { + assumeUninitialized = true; + } + } + } + else if (strictNullChecks && prop && prop.valueDeclaration && + ts.isPropertyAccessExpression(prop.valueDeclaration) && + ts.getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) && + getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) { + assumeUninitialized = true; + } + var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType); + if (assumeUninitialized && !(getFalsyFlags(propType) & 32768) && getFalsyFlags(flowType) & 32768) { + error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop)); + return propType; + } + return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType; + } + function checkPropertyNotUsedBeforeDeclaration(prop, node, right) { + var valueDeclaration = prop.valueDeclaration; + if (!valueDeclaration || ts.getSourceFileOfNode(node).isDeclarationFile) { + return; + } + var diagnosticMessage; + var declarationName = ts.idText(right); + if (isInPropertyInitializer(node) + && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression)) + && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) + && !isPropertyDeclaredInAncestorClass(prop)) { + diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName); + } + else if (valueDeclaration.kind === 245 && + node.parent.kind !== 169 && + !(valueDeclaration.flags & 8388608) && + !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) { + diagnosticMessage = error(right, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName); + } + if (diagnosticMessage) { + ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(valueDeclaration, ts.Diagnostics._0_is_declared_here, declarationName)); + } + } + function isInPropertyInitializer(node) { + return !!ts.findAncestor(node, function (node) { + switch (node.kind) { + case 159: + return true; + case 281: + case 161: + case 163: + case 164: + case 283: + case 154: + case 221: + case 276: + case 273: + case 274: + case 275: + case 268: + case 216: + case 279: + return false; + default: + return ts.isExpressionNode(node) ? false : "quit"; + } + }); + } + function isPropertyDeclaredInAncestorClass(prop) { + if (!(prop.parent.flags & 32)) { + return false; + } + var classType = getTypeOfSymbol(prop.parent); + while (true) { + classType = classType.symbol && getSuperClass(classType); + if (!classType) { + return false; + } + var superProperty = getPropertyOfType(classType, prop.escapedName); + if (superProperty && superProperty.valueDeclaration) { + return true; + } + } + } + function getSuperClass(classType) { + var x = getBaseTypes(classType); + if (x.length === 0) { + return undefined; + } + return getIntersectionType(x); + } + function reportNonexistentProperty(propNode, containingType) { + var errorInfo; + var relatedInfo; + if (!ts.isPrivateIdentifier(propNode) && containingType.flags & 1048576 && !(containingType.flags & 131068)) { + for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) { + var subtype = _a[_i]; + if (!getPropertyOfType(subtype, propNode.escapedText) && !getIndexInfoOfType(subtype, 0)) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(subtype)); + break; + } + } + } + if (typeHasStaticProperty(propNode.escapedText, containingType)) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, ts.declarationNameToString(propNode), typeToString(containingType)); + } + else { + var promisedType = getPromisedTypeOfPromise(containingType); + if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType)); + relatedInfo = ts.createDiagnosticForNode(propNode, ts.Diagnostics.Did_you_forget_to_use_await); + } + else { + var suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType); + if (suggestion !== undefined) { + var suggestedName = ts.symbolName(suggestion); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, ts.declarationNameToString(propNode), typeToString(containingType), suggestedName); + relatedInfo = suggestion.valueDeclaration && ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestedName); + } + else { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType)); + } + } + } + var resultDiagnostic = ts.createDiagnosticForNodeFromMessageChain(propNode, errorInfo); + if (relatedInfo) { + ts.addRelatedInfo(resultDiagnostic, relatedInfo); + } + diagnostics.add(resultDiagnostic); + } + function typeHasStaticProperty(propName, containingType) { + var prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName); + return prop !== undefined && prop.valueDeclaration && ts.hasModifier(prop.valueDeclaration, 32); + } + function getSuggestedSymbolForNonexistentProperty(name, containingType) { + return getSpellingSuggestionForName(ts.isString(name) ? name : ts.idText(name), getPropertiesOfType(containingType), 111551); + } + function getSuggestionForNonexistentProperty(name, containingType) { + var suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType); + return suggestion && ts.symbolName(suggestion); + } + function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) { + ts.Debug.assert(outerName !== undefined, "outername should always be defined"); + var result = resolveNameHelper(location, outerName, meaning, undefined, outerName, false, false, function (symbols, name, meaning) { + ts.Debug.assertEqual(outerName, name, "name should equal outerName"); + var symbol = getSymbol(symbols, name, meaning); + return symbol || getSpellingSuggestionForName(ts.unescapeLeadingUnderscores(name), ts.arrayFrom(symbols.values()), meaning); + }); + return result; + } + function getSuggestionForNonexistentSymbol(location, outerName, meaning) { + var symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning); + return symbolResult && ts.symbolName(symbolResult); + } + function getSuggestedSymbolForNonexistentModule(name, targetModule) { + return targetModule.exports && getSpellingSuggestionForName(ts.idText(name), getExportsOfModuleAsArray(targetModule), 2623475); + } + function getSuggestionForNonexistentExport(name, targetModule) { + var suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule); + return suggestion && ts.symbolName(suggestion); + } + function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) { + function hasProp(name) { + var prop = getPropertyOfObjectType(objectType, name); + if (prop) { + var s = getSingleCallSignature(getTypeOfSymbol(prop)); + return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0)); + } + return false; + } + ; + var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get"; + if (!hasProp(suggestedMethod)) { + return undefined; + } + var suggestion = ts.tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (suggestion === undefined) { + suggestion = suggestedMethod; + } + else { + suggestion += "." + suggestedMethod; + } + return suggestion; + } + function getSpellingSuggestionForName(name, symbols, meaning) { + return ts.getSpellingSuggestion(name, symbols, getCandidateName); + function getCandidateName(candidate) { + var candidateName = ts.symbolName(candidate); + return !ts.startsWith(candidateName, "\"") && candidate.flags & meaning ? candidateName : undefined; + } + } + function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isThisAccess) { + var valueDeclaration = prop && (prop.flags & 106500) && prop.valueDeclaration; + if (!valueDeclaration) { + return; + } + var hasPrivateModifier = ts.hasModifier(valueDeclaration, 8); + var hasPrivateIdentifier = ts.isNamedDeclaration(prop.valueDeclaration) && ts.isPrivateIdentifier(prop.valueDeclaration.name); + if (!hasPrivateModifier && !hasPrivateIdentifier) { + return; + } + if (nodeForCheckWriteOnly && ts.isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 && !(prop.flags & 32768))) { + return; + } + if (isThisAccess) { + var containingMethod = ts.findAncestor(nodeForCheckWriteOnly, ts.isFunctionLikeDeclaration); + if (containingMethod && containingMethod.symbol === prop) { + return; + } + } + (ts.getCheckFlags(prop) & 1 ? getSymbolLinks(prop).target : prop).isReferenced = 67108863; + } + function isValidPropertyAccess(node, propertyName) { + switch (node.kind) { + case 194: + return isValidPropertyAccessWithType(node, node.expression.kind === 102, propertyName, getWidenedType(checkExpression(node.expression))); + case 153: + return isValidPropertyAccessWithType(node, false, propertyName, getWidenedType(checkExpression(node.left))); + case 188: + return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node)); + } + } + function isValidPropertyAccessForCompletions(node, type, property) { + return isValidPropertyAccessWithType(node, node.kind === 194 && node.expression.kind === 102, property.escapedName, type); + } + function isValidPropertyAccessWithType(node, isSuper, propertyName, type) { + if (type === errorType || isTypeAny(type)) { + return true; + } + var prop = getPropertyOfType(type, propertyName); + if (prop) { + if (ts.isPropertyAccessExpression(node) && prop.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(prop.valueDeclaration)) { + var declClass_1 = ts.getContainingClass(prop.valueDeclaration); + return !ts.isOptionalChain(node) && !!ts.findAncestor(node, function (parent) { return parent === declClass_1; }); + } + return checkPropertyAccessibility(node, isSuper, type, prop); + } + return ts.isInJSFile(node) && (type.flags & 1048576) !== 0 && type.types.some(function (elementType) { return isValidPropertyAccessWithType(node, isSuper, propertyName, elementType); }); + } + function getForInVariableSymbol(node) { + var initializer = node.initializer; + if (initializer.kind === 243) { + var variable = initializer.declarations[0]; + if (variable && !ts.isBindingPattern(variable.name)) { + return getSymbolOfNode(variable); + } + } + else if (initializer.kind === 75) { + return getResolvedSymbol(initializer); + } + return undefined; + } + function hasNumericPropertyNames(type) { + return getIndexTypeOfType(type, 1) && !getIndexTypeOfType(type, 0); + } + function isForInVariableForNumericPropertyNames(expr) { + var e = ts.skipParentheses(expr); + if (e.kind === 75) { + var symbol = getResolvedSymbol(e); + if (symbol.flags & 3) { + var child = expr; + var node = expr.parent; + while (node) { + if (node.kind === 231 && + child === node.statement && + getForInVariableSymbol(node) === symbol && + hasNumericPropertyNames(getTypeOfExpression(node.expression))) { + return true; + } + child = node; + node = node.parent; + } + } + } + return false; + } + function checkIndexedAccess(node) { + return node.flags & 32 ? checkElementAccessChain(node) : + checkElementAccessExpression(node, checkNonNullExpression(node.expression)); + } + function checkElementAccessChain(node) { + var exprType = checkExpression(node.expression); + var nonOptionalType = getOptionalExpressionType(exprType, node.expression); + return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression)), node, nonOptionalType !== exprType); + } + function checkElementAccessExpression(node, exprType) { + var objectType = ts.getAssignmentTargetKind(node) !== 0 || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType; + var indexExpression = node.argumentExpression; + var indexType = checkExpression(indexExpression); + if (objectType === errorType || objectType === silentNeverType) { + return objectType; + } + if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) { + error(indexExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal); + return errorType; + } + var effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType; + var accessFlags = ts.isAssignmentTarget(node) ? + 2 | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 1 : 0) : + 0; + var indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, node, accessFlags) || errorType; + return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, indexedAccessType.symbol, indexedAccessType, indexExpression), node); + } + function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) { + if (expressionType === errorType) { + return false; + } + if (!ts.isWellKnownSymbolSyntactically(expression)) { + return false; + } + if ((expressionType.flags & 12288) === 0) { + if (reportError) { + error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression)); + } + return false; + } + var leftHandSide = expression.expression; + var leftHandSideSymbol = getResolvedSymbol(leftHandSide); + if (!leftHandSideSymbol) { + return false; + } + var globalESSymbol = getGlobalESSymbolConstructorSymbol(true); + if (!globalESSymbol) { + return false; + } + if (leftHandSideSymbol !== globalESSymbol) { + if (reportError) { + error(leftHandSide, ts.Diagnostics.Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object); + } + return false; + } + return true; + } + function callLikeExpressionMayHaveTypeArguments(node) { + return ts.isCallOrNewExpression(node) || ts.isTaggedTemplateExpression(node) || ts.isJsxOpeningLikeElement(node); + } + function resolveUntypedCall(node) { + if (callLikeExpressionMayHaveTypeArguments(node)) { + ts.forEach(node.typeArguments, checkSourceElement); + } + if (node.kind === 198) { + checkExpression(node.template); + } + else if (ts.isJsxOpeningLikeElement(node)) { + checkExpression(node.attributes); + } + else if (node.kind !== 157) { + ts.forEach(node.arguments, function (argument) { + checkExpression(argument); + }); + } + return anySignature; + } + function resolveErrorCall(node) { + resolveUntypedCall(node); + return unknownSignature; + } + function reorderCandidates(signatures, result, callChainFlags) { + var lastParent; + var lastSymbol; + var cutoffIndex = 0; + var index; + var specializedIndex = -1; + var spliceIndex; + ts.Debug.assert(!result.length); + for (var _i = 0, signatures_7 = signatures; _i < signatures_7.length; _i++) { + var signature = signatures_7[_i]; + var symbol = signature.declaration && getSymbolOfNode(signature.declaration); + var parent = signature.declaration && signature.declaration.parent; + if (!lastSymbol || symbol === lastSymbol) { + if (lastParent && parent === lastParent) { + index = index + 1; + } + else { + lastParent = parent; + index = cutoffIndex; + } + } + else { + index = cutoffIndex = result.length; + lastParent = parent; + } + lastSymbol = symbol; + if (signatureHasLiteralTypes(signature)) { + specializedIndex++; + spliceIndex = specializedIndex; + cutoffIndex++; + } + else { + spliceIndex = index; + } + result.splice(spliceIndex, 0, callChainFlags ? getOptionalCallSignature(signature, callChainFlags) : signature); + } + } + function isSpreadArgument(arg) { + return !!arg && (arg.kind === 213 || arg.kind === 220 && arg.isSpread); + } + function getSpreadArgumentIndex(args) { + return ts.findIndex(args, isSpreadArgument); + } + function acceptsVoid(t) { + return !!(t.flags & 16384); + } + function hasCorrectArity(node, args, signature, signatureHelpTrailingComma) { + if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; } + var argCount; + var callIsIncomplete = false; + var effectiveParameterCount = getParameterCount(signature); + var effectiveMinimumArguments = getMinArgumentCount(signature); + if (node.kind === 198) { + argCount = args.length; + if (node.template.kind === 211) { + var lastSpan = ts.last(node.template.templateSpans); + callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated; + } + else { + var templateLiteral = node.template; + ts.Debug.assert(templateLiteral.kind === 14); + callIsIncomplete = !!templateLiteral.isUnterminated; + } + } + else if (node.kind === 157) { + argCount = getDecoratorArgumentCount(node, signature); + } + else if (ts.isJsxOpeningLikeElement(node)) { + callIsIncomplete = node.attributes.end === node.end; + if (callIsIncomplete) { + return true; + } + argCount = effectiveMinimumArguments === 0 ? args.length : 1; + effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1; + effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1); + } + else { + if (!node.arguments) { + ts.Debug.assert(node.kind === 197); + return getMinArgumentCount(signature) === 0; + } + argCount = signatureHelpTrailingComma ? args.length + 1 : args.length; + callIsIncomplete = node.arguments.end === node.end; + var spreadArgIndex = getSpreadArgumentIndex(args); + if (spreadArgIndex >= 0) { + return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature)); + } + } + if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) { + return false; + } + if (callIsIncomplete || argCount >= effectiveMinimumArguments) { + return true; + } + for (var i = argCount; i < effectiveMinimumArguments; i++) { + var type = getTypeAtPosition(signature, i); + if (filterType(type, acceptsVoid).flags & 131072) { + return false; + } + } + return true; + } + function hasCorrectTypeArgumentArity(signature, typeArguments) { + var numTypeParameters = ts.length(signature.typeParameters); + var minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters); + return !ts.some(typeArguments) || + (typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters); + } + function getSingleCallSignature(type) { + return getSingleSignature(type, 0, false); + } + function getSingleCallOrConstructSignature(type) { + return getSingleSignature(type, 0, false) || + getSingleSignature(type, 1, false); + } + function getSingleSignature(type, kind, allowMembers) { + if (type.flags & 524288) { + var resolved = resolveStructuredTypeMembers(type); + if (allowMembers || resolved.properties.length === 0 && !resolved.stringIndexInfo && !resolved.numberIndexInfo) { + if (kind === 0 && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) { + return resolved.callSignatures[0]; + } + if (kind === 1 && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) { + return resolved.constructSignatures[0]; + } + } + } + return undefined; + } + function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) { + var context = createInferenceContext(signature.typeParameters, signature, 0, compareTypes); + var restType = getEffectiveRestType(contextualSignature); + var mapper = inferenceContext && (restType && restType.flags & 262144 ? inferenceContext.nonFixingMapper : inferenceContext.mapper); + var sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature; + applyToParameterTypes(sourceSignature, signature, function (source, target) { + inferTypes(context.inferences, source, target); + }); + if (!inferenceContext) { + applyToReturnTypes(contextualSignature, signature, function (source, target) { + inferTypes(context.inferences, source, target, 32); + }); + } + return getSignatureInstantiation(signature, getInferredTypes(context), ts.isInJSFile(contextualSignature.declaration)); + } + function inferJsxTypeArguments(node, signature, checkMode, context) { + var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node); + var checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode); + inferTypes(context.inferences, checkAttrType, paramType); + return getInferredTypes(context); + } + function inferTypeArguments(node, signature, args, checkMode, context) { + if (ts.isJsxOpeningLikeElement(node)) { + return inferJsxTypeArguments(node, signature, checkMode, context); + } + if (node.kind !== 157) { + var contextualType = getContextualType(node); + if (contextualType) { + var outerContext = getInferenceContext(node); + var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1)); + var instantiatedType = instantiateType(contextualType, outerMapper); + var contextualSignature = getSingleCallSignature(instantiatedType); + var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? + getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : + instantiatedType; + var inferenceTargetType = getReturnTypeOfSignature(signature); + inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 32); + var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags); + var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper); + inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType); + context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined; + } + } + var thisType = getThisTypeOfSignature(signature); + if (thisType) { + var thisArgumentNode = getThisArgumentOfCall(node); + var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType; + inferTypes(context.inferences, thisArgumentType, thisType); + } + var restType = getNonArrayRestType(signature); + var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length; + for (var i = 0; i < argCount; i++) { + var arg = args[i]; + if (arg.kind !== 215) { + var paramType = getTypeAtPosition(signature, i); + var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode); + inferTypes(context.inferences, argType, paramType); + } + } + if (restType) { + var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context); + inferTypes(context.inferences, spreadType, restType); + } + return getInferredTypes(context); + } + function getArrayifiedType(type) { + return type.flags & 1048576 ? mapType(type, getArrayifiedType) : + type.flags & (1 | 63176704) || isMutableArrayOrTuple(type) ? type : + isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.minLength, type.target.hasRestElement, false, type.target.associatedNames) : + createArrayType(getIndexedAccessType(type, numberType)); + } + function getSpreadArgumentType(args, index, argCount, restType, context) { + if (index >= argCount - 1) { + var arg = args[argCount - 1]; + if (isSpreadArgument(arg)) { + return arg.kind === 220 ? + createArrayType(arg.type) : + getArrayifiedType(checkExpressionWithContextualType(arg.expression, restType, context, 0)); + } + } + var types = []; + var spreadIndex = -1; + for (var i = index; i < argCount; i++) { + var contextualType = getIndexedAccessType(restType, getLiteralType(i - index)); + var argType = checkExpressionWithContextualType(args[i], contextualType, context, 0); + if (spreadIndex < 0 && isSpreadArgument(args[i])) { + spreadIndex = i - index; + } + var hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 | 4194304); + types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType)); + } + return spreadIndex < 0 ? + createTupleType(types) : + createTupleType(ts.append(types.slice(0, spreadIndex), getUnionType(types.slice(spreadIndex))), spreadIndex, true); + } + function checkTypeArguments(signature, typeArgumentNodes, reportErrors, headMessage) { + var isJavascript = ts.isInJSFile(signature.declaration); + var typeParameters = signature.typeParameters; + var typeArgumentTypes = fillMissingTypeArguments(ts.map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); + var mapper; + for (var i = 0; i < typeArgumentNodes.length; i++) { + ts.Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments"); + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var errorInfo = reportErrors && headMessage ? (function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); }) : undefined; + var typeArgumentHeadMessage = headMessage || ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (!mapper) { + mapper = createTypeMapper(typeParameters, typeArgumentTypes); + } + var typeArgument = typeArgumentTypes[i]; + if (!checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), reportErrors ? typeArgumentNodes[i] : undefined, typeArgumentHeadMessage, errorInfo)) { + return undefined; + } + } + } + return typeArgumentTypes; + } + function getJsxReferenceKind(node) { + if (isJsxIntrinsicIdentifier(node.tagName)) { + return 2; + } + var tagType = getApparentType(checkExpression(node.tagName)); + if (ts.length(getSignaturesOfType(tagType, 1))) { + return 0; + } + if (ts.length(getSignaturesOfType(tagType, 0))) { + return 1; + } + return 2; + } + function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer) { + var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node); + var attributesType = checkExpressionWithContextualType(node.attributes, paramType, undefined, checkMode); + return checkTypeRelatedToAndOptionallyElaborate(attributesType, paramType, relation, reportErrors ? node.tagName : undefined, node.attributes, undefined, containingMessageChain, errorOutputContainer); + } + function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors, containingMessageChain) { + var errorOutputContainer = { errors: undefined, skipLogging: true }; + if (ts.isJsxOpeningLikeElement(node)) { + if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "jsx should have errors when reporting errors"); + return errorOutputContainer.errors || ts.emptyArray; + } + return undefined; + } + var thisType = getThisTypeOfSignature(signature); + if (thisType && thisType !== voidType && node.kind !== 197) { + var thisArgumentNode = getThisArgumentOfCall(node); + var thisArgumentType = void 0; + if (thisArgumentNode) { + thisArgumentType = checkExpression(thisArgumentNode); + if (ts.isOptionalChainRoot(thisArgumentNode.parent)) { + thisArgumentType = getNonNullableType(thisArgumentType); + } + else if (ts.isOptionalChain(thisArgumentNode.parent)) { + thisArgumentType = removeOptionalTypeMarker(thisArgumentType); + } + } + else { + thisArgumentType = voidType; + } + var errorNode = reportErrors ? (thisArgumentNode || node) : undefined; + var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1; + if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage_1, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors"); + return errorOutputContainer.errors || ts.emptyArray; + } + } + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + var restType = getNonArrayRestType(signature); + var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length; + for (var i = 0; i < argCount; i++) { + var arg = args[i]; + if (arg.kind !== 215) { + var paramType = getTypeAtPosition(signature, i); + var argType = checkExpressionWithContextualType(arg, paramType, undefined, checkMode); + var checkArgType = checkMode & 4 ? getRegularTypeOfObjectLiteral(argType) : argType; + if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? arg : undefined, arg, headMessage, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors"); + maybeAddMissingAwaitInfo(arg, checkArgType, paramType); + return errorOutputContainer.errors || ts.emptyArray; + } + } + } + if (restType) { + var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, undefined); + var errorNode = reportErrors ? argCount < args.length ? args[argCount] : node : undefined; + if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, undefined, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors"); + maybeAddMissingAwaitInfo(errorNode, spreadType, restType); + return errorOutputContainer.errors || ts.emptyArray; + } + } + return undefined; + function maybeAddMissingAwaitInfo(errorNode, source, target) { + if (errorNode && reportErrors && errorOutputContainer.errors && errorOutputContainer.errors.length) { + if (getAwaitedTypeOfPromise(target)) { + return; + } + var awaitedTypeOfSource = getAwaitedTypeOfPromise(source); + if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) { + ts.addRelatedInfo(errorOutputContainer.errors[0], ts.createDiagnosticForNode(errorNode, ts.Diagnostics.Did_you_forget_to_use_await)); + } + } + } + } + function getThisArgumentOfCall(node) { + if (node.kind === 196) { + var callee = ts.skipOuterExpressions(node.expression); + if (ts.isAccessExpression(callee)) { + return callee.expression; + } + } + } + function createSyntheticExpression(parent, type, isSpread) { + var result = ts.createNode(220, parent.pos, parent.end); + result.parent = parent; + result.type = type; + result.isSpread = isSpread || false; + return result; + } + function getEffectiveCallArguments(node) { + if (node.kind === 198) { + var template = node.template; + var args_3 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())]; + if (template.kind === 211) { + ts.forEach(template.templateSpans, function (span) { + args_3.push(span.expression); + }); + } + return args_3; + } + if (node.kind === 157) { + return getEffectiveDecoratorArguments(node); + } + if (ts.isJsxOpeningLikeElement(node)) { + return node.attributes.properties.length > 0 || (ts.isJsxOpeningElement(node) && node.parent.children.length > 0) ? [node.attributes] : ts.emptyArray; + } + var args = node.arguments || ts.emptyArray; + var length = args.length; + if (length && isSpreadArgument(args[length - 1]) && getSpreadArgumentIndex(args) === length - 1) { + var spreadArgument_1 = args[length - 1]; + var type = flowLoopCount ? checkExpression(spreadArgument_1.expression) : checkExpressionCached(spreadArgument_1.expression); + if (isTupleType(type)) { + var typeArguments = getTypeArguments(type); + var restIndex_2 = type.target.hasRestElement ? typeArguments.length - 1 : -1; + var syntheticArgs = ts.map(typeArguments, function (t, i) { return createSyntheticExpression(spreadArgument_1, t, i === restIndex_2); }); + return ts.concatenate(args.slice(0, length - 1), syntheticArgs); + } + } + return args; + } + function getEffectiveDecoratorArguments(node) { + var parent = node.parent; + var expr = node.expression; + switch (parent.kind) { + case 245: + case 214: + return [ + createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent))) + ]; + case 156: + var func = parent.parent; + return [ + createSyntheticExpression(expr, parent.parent.kind === 162 ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType), + createSyntheticExpression(expr, anyType), + createSyntheticExpression(expr, numberType) + ]; + case 159: + case 161: + case 163: + case 164: + var hasPropDesc = parent.kind !== 159 && languageVersion !== 0; + return [ + createSyntheticExpression(expr, getParentTypeOfClassElement(parent)), + createSyntheticExpression(expr, getClassElementPropertyKeyType(parent)), + createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent)) : anyType) + ]; + } + return ts.Debug.fail(); + } + function getDecoratorArgumentCount(node, signature) { + switch (node.parent.kind) { + case 245: + case 214: + return 1; + case 159: + return 2; + case 161: + case 163: + case 164: + return languageVersion === 0 || signature.parameters.length <= 2 ? 2 : 3; + case 156: + return 3; + default: + return ts.Debug.fail(); + } + } + function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) { + var start; + var length; + var sourceFile = ts.getSourceFileOfNode(node); + if (ts.isPropertyAccessExpression(node.expression)) { + var nameSpan = ts.getErrorSpanForNode(sourceFile, node.expression.name); + start = nameSpan.start; + length = doNotIncludeArguments ? nameSpan.length : node.end - start; + } + else { + var expressionSpan = ts.getErrorSpanForNode(sourceFile, node.expression); + start = expressionSpan.start; + length = doNotIncludeArguments ? expressionSpan.length : node.end - start; + } + return { start: start, length: length, sourceFile: sourceFile }; + } + function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) { + if (ts.isCallExpression(node)) { + var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_4 = _a.length; + return ts.createFileDiagnostic(sourceFile, start, length_4, message, arg0, arg1, arg2, arg3); + } + else { + return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3); + } + } + function getArgumentArityError(node, signatures, args) { + var min = Number.POSITIVE_INFINITY; + var max = Number.NEGATIVE_INFINITY; + var belowArgCount = Number.NEGATIVE_INFINITY; + var aboveArgCount = Number.POSITIVE_INFINITY; + var argCount = args.length; + var closestSignature; + for (var _i = 0, signatures_8 = signatures; _i < signatures_8.length; _i++) { + var sig = signatures_8[_i]; + var minCount = getMinArgumentCount(sig); + var maxCount = getParameterCount(sig); + if (minCount < argCount && minCount > belowArgCount) + belowArgCount = minCount; + if (argCount < maxCount && maxCount < aboveArgCount) + aboveArgCount = maxCount; + if (minCount < min) { + min = minCount; + closestSignature = sig; + } + max = Math.max(max, maxCount); + } + var hasRestParameter = ts.some(signatures, hasEffectiveRestParameter); + var paramRange = hasRestParameter ? min : + min < max ? min + "-" + max : + min; + var hasSpreadArgument = getSpreadArgumentIndex(args) > -1; + if (argCount <= max && hasSpreadArgument) { + argCount--; + } + var spanArray; + var related; + var error = hasRestParameter || hasSpreadArgument ? hasRestParameter && hasSpreadArgument ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1_or_more : + hasRestParameter ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1 : + ts.Diagnostics.Expected_0_arguments_but_got_1_or_more : ts.Diagnostics.Expected_0_arguments_but_got_1; + if (closestSignature && getMinArgumentCount(closestSignature) > argCount && closestSignature.declaration) { + var paramDecl = closestSignature.declaration.parameters[closestSignature.thisParameter ? argCount + 1 : argCount]; + if (paramDecl) { + related = ts.createDiagnosticForNode(paramDecl, ts.isBindingPattern(paramDecl.name) ? ts.Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : ts.Diagnostics.An_argument_for_0_was_not_provided, !paramDecl.name ? argCount : !ts.isBindingPattern(paramDecl.name) ? ts.idText(ts.getFirstIdentifier(paramDecl.name)) : undefined); + } + } + if (min < argCount && argCount < max) { + return getDiagnosticForCallNode(node, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, argCount, belowArgCount, aboveArgCount); + } + if (!hasSpreadArgument && argCount < min) { + var diagnostic_1 = getDiagnosticForCallNode(node, error, paramRange, argCount); + return related ? ts.addRelatedInfo(diagnostic_1, related) : diagnostic_1; + } + if (hasRestParameter || hasSpreadArgument) { + spanArray = ts.createNodeArray(args); + if (hasSpreadArgument && argCount) { + var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined; + spanArray = ts.createNodeArray(args.slice(max > argCount && nextArg ? args.indexOf(nextArg) : Math.min(max, args.length - 1))); + } + } + else { + spanArray = ts.createNodeArray(args.slice(max)); + } + spanArray.pos = ts.first(spanArray).pos; + spanArray.end = ts.last(spanArray).end; + if (spanArray.end === spanArray.pos) { + spanArray.end++; + } + var diagnostic = ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), spanArray, error, paramRange, argCount); + return related ? ts.addRelatedInfo(diagnostic, related) : diagnostic; + } + function getTypeArgumentArityError(node, signatures, typeArguments) { + var argCount = typeArguments.length; + if (signatures.length === 1) { + var sig = signatures[0]; + var min_1 = getMinTypeArgumentCount(sig.typeParameters); + var max = ts.length(sig.typeParameters); + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount); + } + var belowArgCount = -Infinity; + var aboveArgCount = Infinity; + for (var _i = 0, signatures_9 = signatures; _i < signatures_9.length; _i++) { + var sig = signatures_9[_i]; + var min_2 = getMinTypeArgumentCount(sig.typeParameters); + var max = ts.length(sig.typeParameters); + if (min_2 > argCount) { + aboveArgCount = Math.min(aboveArgCount, min_2); + } + else if (max < argCount) { + belowArgCount = Math.max(belowArgCount, max); + } + } + if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) { + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount); + } + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount); + } + function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) { + var isTaggedTemplate = node.kind === 198; + var isDecorator = node.kind === 157; + var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node); + var reportErrors = !candidatesOutArray; + var typeArguments; + if (!isDecorator) { + typeArguments = node.typeArguments; + if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 102) { + ts.forEach(typeArguments, checkSourceElement); + } + } + var candidates = candidatesOutArray || []; + reorderCandidates(signatures, candidates, callChainFlags); + if (!candidates.length) { + if (reportErrors) { + diagnostics.add(getDiagnosticForCallNode(node, ts.Diagnostics.Call_target_does_not_contain_any_signatures)); + } + return resolveErrorCall(node); + } + var args = getEffectiveCallArguments(node); + var isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters; + var argCheckMode = !isDecorator && !isSingleNonGenericCandidate && ts.some(args, isContextSensitive) ? 4 : 0; + var candidatesForArgumentError; + var candidateForArgumentArityError; + var candidateForTypeArgumentError; + var result; + var signatureHelpTrailingComma = !!(checkMode & 16) && node.kind === 196 && node.arguments.hasTrailingComma; + if (candidates.length > 1) { + result = chooseOverload(candidates, subtypeRelation, signatureHelpTrailingComma); + } + if (!result) { + result = chooseOverload(candidates, assignableRelation, signatureHelpTrailingComma); + } + if (result) { + return result; + } + if (reportErrors) { + if (candidatesForArgumentError) { + if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) { + var last_2 = candidatesForArgumentError[candidatesForArgumentError.length - 1]; + var chain_1; + if (candidatesForArgumentError.length > 3) { + chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.The_last_overload_gave_the_following_error); + chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.No_overload_matches_this_call); + } + var diags = getSignatureApplicabilityError(node, args, last_2, assignableRelation, 0, true, function () { return chain_1; }); + if (diags) { + for (var _i = 0, diags_1 = diags; _i < diags_1.length; _i++) { + var d = diags_1[_i]; + if (last_2.declaration && candidatesForArgumentError.length > 3) { + ts.addRelatedInfo(d, ts.createDiagnosticForNode(last_2.declaration, ts.Diagnostics.The_last_overload_is_declared_here)); + } + diagnostics.add(d); + } + } + else { + ts.Debug.fail("No error for last overload signature"); + } + } + else { + var allDiagnostics = []; + var max = 0; + var min_3 = Number.MAX_VALUE; + var minIndex = 0; + var i_1 = 0; + var _loop_15 = function (c) { + var chain_2 = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); }; + var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0, true, chain_2); + if (diags_2) { + if (diags_2.length <= min_3) { + min_3 = diags_2.length; + minIndex = i_1; + } + max = Math.max(max, diags_2.length); + allDiagnostics.push(diags_2); + } + else { + ts.Debug.fail("No error for 3 or fewer overload signatures"); + } + i_1++; + }; + for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) { + var c = candidatesForArgumentError_1[_a]; + _loop_15(c); + } + var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics); + ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures"); + var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call); + var related = ts.flatMap(diags_3, function (d) { return d.relatedInformation; }); + if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) { + var _b = diags_3[0], file = _b.file, start = _b.start, length_5 = _b.length; + diagnostics.add({ file: file, start: start, length: length_5, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related }); + } + else { + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, chain, related)); + } + } + } + else if (candidateForArgumentArityError) { + diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args)); + } + else if (candidateForTypeArgumentError) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError); + } + else { + var signaturesWithCorrectTypeArgumentArity = ts.filter(signatures, function (s) { return hasCorrectTypeArgumentArity(s, typeArguments); }); + if (signaturesWithCorrectTypeArgumentArity.length === 0) { + diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments)); + } + else if (!isDecorator) { + diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args)); + } + else if (fallbackError) { + diagnostics.add(getDiagnosticForCallNode(node, fallbackError)); + } + } + } + return produceDiagnostics || !args ? resolveErrorCall(node) : getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray); + function chooseOverload(candidates, relation, signatureHelpTrailingComma) { + if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; } + candidatesForArgumentError = undefined; + candidateForArgumentArityError = undefined; + candidateForTypeArgumentError = undefined; + if (isSingleNonGenericCandidate) { + var candidate = candidates[0]; + if (ts.some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) { + return undefined; + } + if (getSignatureApplicabilityError(node, args, candidate, relation, 0, false, undefined)) { + candidatesForArgumentError = [candidate]; + return undefined; + } + return candidate; + } + for (var candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) { + var candidate = candidates[candidateIndex]; + if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) { + continue; + } + var checkCandidate = void 0; + var inferenceContext = void 0; + if (candidate.typeParameters) { + var typeArgumentTypes = void 0; + if (ts.some(typeArguments)) { + typeArgumentTypes = checkTypeArguments(candidate, typeArguments, false); + if (!typeArgumentTypes) { + candidateForTypeArgumentError = candidate; + continue; + } + } + else { + inferenceContext = createInferenceContext(candidate.typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0); + typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8, inferenceContext); + argCheckMode |= inferenceContext.flags & 4 ? 8 : 0; + } + checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters); + if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) { + candidateForArgumentArityError = checkCandidate; + continue; + } + } + else { + checkCandidate = candidate; + } + if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) { + (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate); + continue; + } + if (argCheckMode) { + argCheckMode = 0; + if (inferenceContext) { + var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext); + checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters); + if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) { + candidateForArgumentArityError = checkCandidate; + continue; + } + } + if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) { + (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate); + continue; + } + } + candidates[candidateIndex] = checkCandidate; + return checkCandidate; + } + return undefined; + } + } + function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) { + ts.Debug.assert(candidates.length > 0); + return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; }) + ? pickLongestCandidateSignature(node, candidates, args) + : createUnionOfSignaturesForOverloadFailure(candidates); + } + function createUnionOfSignaturesForOverloadFailure(candidates) { + var thisParameters = ts.mapDefined(candidates, function (c) { return c.thisParameter; }); + var thisParameter; + if (thisParameters.length) { + thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter)); + } + var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max; + var parameters = []; + var _loop_16 = function (i) { + var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ? + i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) : + i < s.parameters.length ? s.parameters[i] : undefined; }); + ts.Debug.assert(symbols.length !== 0); + parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); }))); + }; + for (var i = 0; i < maxNonRestParam; i++) { + _loop_16(i); + } + var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; }); + var flags = 0; + if (restParameterSymbols.length !== 0) { + var type = createArrayType(getUnionType(ts.mapDefined(candidates, tryGetRestTypeOfSignature), 2)); + parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type)); + flags |= 1; + } + if (candidates.some(signatureHasLiteralTypes)) { + flags |= 2; + } + return createSignature(candidates[0].declaration, undefined, thisParameter, parameters, getIntersectionType(candidates.map(getReturnTypeOfSignature)), undefined, minArgumentCount, flags); + } + function getNumNonRestParameters(signature) { + var numParams = signature.parameters.length; + return signatureHasRestParameter(signature) ? numParams - 1 : numParams; + } + function createCombinedSymbolFromTypes(sources, types) { + return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2)); + } + function createCombinedSymbolForOverloadFailure(sources, type) { + return createSymbolWithType(ts.first(sources), type); + } + function pickLongestCandidateSignature(node, candidates, args) { + var bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === undefined ? args.length : apparentArgumentCount); + var candidate = candidates[bestIndex]; + var typeParameters = candidate.typeParameters; + if (!typeParameters) { + return candidate; + } + var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined; + var instantiated = typeArgumentNodes + ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node))) + : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args); + candidates[bestIndex] = instantiated; + return instantiated; + } + function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) { + var typeArguments = typeArgumentNodes.map(getTypeOfNode); + while (typeArguments.length > typeParameters.length) { + typeArguments.pop(); + } + while (typeArguments.length < typeParameters.length) { + typeArguments.push(getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs)); + } + return typeArguments; + } + function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) { + var inferenceContext = createInferenceContext(typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0); + var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 | 8, inferenceContext); + return createSignatureInstantiation(candidate, typeArgumentTypes); + } + function getLongestCandidateIndex(candidates, argsCount) { + var maxParamsIndex = -1; + var maxParams = -1; + for (var i = 0; i < candidates.length; i++) { + var candidate = candidates[i]; + var paramCount = getParameterCount(candidate); + if (hasEffectiveRestParameter(candidate) || paramCount >= argsCount) { + return i; + } + if (paramCount > maxParams) { + maxParams = paramCount; + maxParamsIndex = i; + } + } + return maxParamsIndex; + } + function resolveCallExpression(node, candidatesOutArray, checkMode) { + if (node.expression.kind === 102) { + var superType = checkSuperExpression(node.expression); + if (isTypeAny(superType)) { + for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) { + var arg = _a[_i]; + checkExpression(arg); + } + return anySignature; + } + if (superType !== errorType) { + var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node)); + if (baseTypeNode) { + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode); + return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0); + } + } + return resolveUntypedCall(node); + } + var callChainFlags; + var funcType = checkExpression(node.expression); + if (ts.isCallChain(node)) { + var nonOptionalType = getOptionalExpressionType(funcType, node.expression); + callChainFlags = nonOptionalType === funcType ? 0 : + ts.isOutermostOptionalChain(node) ? 8 : + 4; + funcType = nonOptionalType; + } + else { + callChainFlags = 0; + } + funcType = checkNonNullTypeWithReporter(funcType, node.expression, reportCannotInvokePossiblyNullOrUndefinedError); + if (funcType === silentNeverType) { + return silentNeverSignature; + } + var apparentType = getApparentType(funcType); + if (apparentType === errorType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + var numConstructSignatures = getSignaturesOfType(apparentType, 1).length; + if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) { + if (funcType !== errorType && node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + if (!callSignatures.length) { + if (numConstructSignatures) { + error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); + } + else { + var relatedInformation = void 0; + if (node.arguments.length === 1) { + var text = ts.getSourceFileOfNode(node).text; + if (ts.isLineBreak(text.charCodeAt(ts.skipTrivia(text, node.expression.end, true) - 1))) { + relatedInformation = ts.createDiagnosticForNode(node.expression, ts.Diagnostics.It_is_highly_likely_that_you_are_missing_a_semicolon); + } + } + invocationError(node.expression, apparentType, 0, relatedInformation); + } + return resolveErrorCall(node); + } + if (checkMode & 8 && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) { + skippedGenericFunction(node, checkMode); + return resolvingSignature; + } + if (callSignatures.some(function (sig) { return ts.isInJSFile(sig.declaration) && !!ts.getJSDocClassTag(sig.declaration); })) { + error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags); + } + function isGenericFunctionReturningFunction(signature) { + return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature))); + } + function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) { + return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144) || + !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & (1048576 | 131072)) && isTypeAssignableTo(funcType, globalFunctionType); + } + function resolveNewExpression(node, candidatesOutArray, checkMode) { + if (node.arguments && languageVersion < 1) { + var spreadIndex = getSpreadArgumentIndex(node.arguments); + if (spreadIndex >= 0) { + error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher); + } + } + var expressionType = checkNonNullExpression(node.expression); + if (expressionType === silentNeverType) { + return silentNeverSignature; + } + expressionType = getApparentType(expressionType); + if (expressionType === errorType) { + return resolveErrorCall(node); + } + if (isTypeAny(expressionType)) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + var constructSignatures = getSignaturesOfType(expressionType, 1); + if (constructSignatures.length) { + if (!isConstructorAccessible(node, constructSignatures[0])) { + return resolveErrorCall(node); + } + var valueDecl = expressionType.symbol && ts.getClassLikeDeclarationOfSymbol(expressionType.symbol); + if (valueDecl && ts.hasModifier(valueDecl, 128)) { + error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class); + return resolveErrorCall(node); + } + return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0); + } + var callSignatures = getSignaturesOfType(expressionType, 0); + if (callSignatures.length) { + var signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0); + if (!noImplicitAny) { + if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) { + error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword); + } + if (getThisTypeOfSignature(signature) === voidType) { + error(node, ts.Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void); + } + } + return signature; + } + invocationError(node.expression, expressionType, 1); + return resolveErrorCall(node); + } + function typeHasProtectedAccessibleBase(target, type) { + var baseTypes = getBaseTypes(type); + if (!ts.length(baseTypes)) { + return false; + } + var firstBase = baseTypes[0]; + if (firstBase.flags & 2097152) { + var types = firstBase.types; + var mixinFlags = findMixins(types); + var i = 0; + for (var _i = 0, _a = firstBase.types; _i < _a.length; _i++) { + var intersectionMember = _a[_i]; + if (!mixinFlags[i]) { + if (ts.getObjectFlags(intersectionMember) & (1 | 2)) { + if (intersectionMember.symbol === target) { + return true; + } + if (typeHasProtectedAccessibleBase(target, intersectionMember)) { + return true; + } + } + } + i++; + } + return false; + } + if (firstBase.symbol === target) { + return true; + } + return typeHasProtectedAccessibleBase(target, firstBase); + } + function isConstructorAccessible(node, signature) { + if (!signature || !signature.declaration) { + return true; + } + var declaration = signature.declaration; + var modifiers = ts.getSelectedModifierFlags(declaration, 24); + if (!modifiers || declaration.kind !== 162) { + return true; + } + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(declaration.parent.symbol); + var declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol); + if (!isNodeWithinClass(node, declaringClassDeclaration)) { + var containingClass = ts.getContainingClass(node); + if (containingClass && modifiers & 16) { + var containingType = getTypeOfNode(containingClass); + if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) { + return true; + } + } + if (modifiers & 8) { + error(node, ts.Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass)); + } + if (modifiers & 16) { + error(node, ts.Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass)); + } + return false; + } + return true; + } + function invocationErrorDetails(apparentType, kind) { + var errorInfo; + var isCall = kind === 0; + var awaitedType = getAwaitedType(apparentType); + var maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0; + if (apparentType.flags & 1048576) { + var types = apparentType.types; + var hasSignatures = false; + for (var _i = 0, types_17 = types; _i < types_17.length; _i++) { + var constituent = types_17[_i]; + var signatures = getSignaturesOfType(constituent, kind); + if (signatures.length !== 0) { + hasSignatures = true; + if (errorInfo) { + break; + } + } + else { + if (!errorInfo) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Type_0_has_no_call_signatures : + ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(constituent)); + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Not_all_constituents_of_type_0_are_callable : + ts.Diagnostics.Not_all_constituents_of_type_0_are_constructable, typeToString(apparentType)); + } + if (hasSignatures) { + break; + } + } + } + if (!hasSignatures) { + errorInfo = ts.chainDiagnosticMessages(undefined, isCall ? + ts.Diagnostics.No_constituent_of_type_0_is_callable : + ts.Diagnostics.No_constituent_of_type_0_is_constructable, typeToString(apparentType)); + } + if (!errorInfo) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other : + ts.Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other, typeToString(apparentType)); + } + } + else { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Type_0_has_no_call_signatures : + ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(apparentType)); + } + return { + messageChain: ts.chainDiagnosticMessages(errorInfo, isCall ? ts.Diagnostics.This_expression_is_not_callable : ts.Diagnostics.This_expression_is_not_constructable), + relatedMessage: maybeMissingAwait ? ts.Diagnostics.Did_you_forget_to_use_await : undefined, + }; + } + function invocationError(errorTarget, apparentType, kind, relatedInformation) { + var _a = invocationErrorDetails(apparentType, kind), messageChain = _a.messageChain, relatedInfo = _a.relatedMessage; + var diagnostic = ts.createDiagnosticForNodeFromMessageChain(errorTarget, messageChain); + if (relatedInfo) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(errorTarget, relatedInfo)); + } + if (ts.isCallExpression(errorTarget.parent)) { + var _b = getDiagnosticSpanForCallNode(errorTarget.parent, true), start = _b.start, length_6 = _b.length; + diagnostic.start = start; + diagnostic.length = length_6; + } + diagnostics.add(diagnostic); + invocationErrorRecovery(apparentType, kind, relatedInformation ? ts.addRelatedInfo(diagnostic, relatedInformation) : diagnostic); + } + function invocationErrorRecovery(apparentType, kind, diagnostic) { + if (!apparentType.symbol) { + return; + } + var importNode = getSymbolLinks(apparentType.symbol).originatingImport; + if (importNode && !ts.isImportCall(importNode)) { + var sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind); + if (!sigs || !sigs.length) + return; + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(importNode, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead)); + } + } + function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) { + var tagType = checkExpression(node.tag); + var apparentType = getApparentType(tagType); + if (apparentType === errorType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + var numConstructSignatures = getSignaturesOfType(apparentType, 1).length; + if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) { + return resolveUntypedCall(node); + } + if (!callSignatures.length) { + invocationError(node.tag, apparentType, 0); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0); + } + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 245: + case 214: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 156: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 159: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 161: + case 163: + case 164: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + default: + return ts.Debug.fail(); + } + } + function resolveDecorator(node, candidatesOutArray, checkMode) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === errorType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + var numConstructSignatures = getSignaturesOfType(apparentType, 1).length; + if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) { + return resolveUntypedCall(node); + } + if (isPotentiallyUncalledDecorator(node, callSignatures)) { + var nodeStr = ts.getTextOfNode(node.expression, false); + error(node, ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr); + return resolveErrorCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorDetails = invocationErrorDetails(apparentType, 0); + var messageChain = ts.chainDiagnosticMessages(errorDetails.messageChain, headMessage); + var diag = ts.createDiagnosticForNodeFromMessageChain(node.expression, messageChain); + if (errorDetails.relatedMessage) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(node.expression, errorDetails.relatedMessage)); + } + diagnostics.add(diag); + invocationErrorRecovery(apparentType, 0, diag); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0, headMessage); + } + function createSignatureForJSXIntrinsic(node, result) { + var namespace = getJsxNamespaceAt(node); + var exports = namespace && getExportsOfSymbol(namespace); + var typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968); + var returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968, node); + var declaration = ts.createFunctionTypeNode(undefined, [ts.createParameter(undefined, undefined, undefined, "props", undefined, nodeBuilder.typeToTypeNode(result, node))], returnNode ? ts.createTypeReferenceNode(returnNode, undefined) : ts.createKeywordTypeNode(125)); + var parameterSymbol = createSymbol(1, "props"); + parameterSymbol.type = result; + return createSignature(declaration, undefined, undefined, [parameterSymbol], typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType, undefined, 1, 0); + } + function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) { + if (isJsxIntrinsicIdentifier(node.tagName)) { + var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node); + var fakeSignature = createSignatureForJSXIntrinsic(node, result); + checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), undefined, 0), result, node.tagName, node.attributes); + return fakeSignature; + } + var exprTypes = checkExpression(node.tagName); + var apparentType = getApparentType(exprTypes); + if (apparentType === errorType) { + return resolveErrorCall(node); + } + var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node); + if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, 0)) { + return resolveUntypedCall(node); + } + if (signatures.length === 0) { + error(node.tagName, ts.Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, ts.getTextOfNode(node.tagName)); + return resolveErrorCall(node); + } + return resolveCall(node, signatures, candidatesOutArray, checkMode, 0); + } + function isPotentiallyUncalledDecorator(decorator, signatures) { + return signatures.length && ts.every(signatures, function (signature) { + return signature.minArgumentCount === 0 && + !signatureHasRestParameter(signature) && + signature.parameters.length < getDecoratorArgumentCount(decorator, signature); + }); + } + function resolveSignature(node, candidatesOutArray, checkMode) { + switch (node.kind) { + case 196: + return resolveCallExpression(node, candidatesOutArray, checkMode); + case 197: + return resolveNewExpression(node, candidatesOutArray, checkMode); + case 198: + return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode); + case 157: + return resolveDecorator(node, candidatesOutArray, checkMode); + case 268: + case 267: + return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode); + } + throw ts.Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable."); + } + function getResolvedSignature(node, candidatesOutArray, checkMode) { + var links = getNodeLinks(node); + var cached = links.resolvedSignature; + if (cached && cached !== resolvingSignature && !candidatesOutArray) { + return cached; + } + links.resolvedSignature = resolvingSignature; + var result = resolveSignature(node, candidatesOutArray, checkMode || 0); + if (result !== resolvingSignature) { + links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached; + } + return result; + } + function isJSConstructor(node) { + if (!node || !ts.isInJSFile(node)) { + return false; + } + var func = ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ? node : + ts.isVariableDeclaration(node) && node.initializer && ts.isFunctionExpression(node.initializer) ? node.initializer : + undefined; + if (func) { + if (ts.getJSDocClassTag(node)) + return true; + var symbol = getSymbolOfNode(func); + return !!symbol && ts.hasEntries(symbol.members); + } + return false; + } + function mergeJSSymbols(target, source) { + if (source) { + var links = getSymbolLinks(source); + if (!links.inferredClassSymbol || !links.inferredClassSymbol.has("" + getSymbolId(target))) { + var inferred = ts.isTransientSymbol(target) ? target : cloneSymbol(target); + inferred.exports = inferred.exports || ts.createSymbolTable(); + inferred.members = inferred.members || ts.createSymbolTable(); + inferred.flags |= source.flags & 32; + if (ts.hasEntries(source.exports)) { + mergeSymbolTable(inferred.exports, source.exports); + } + if (ts.hasEntries(source.members)) { + mergeSymbolTable(inferred.members, source.members); + } + (links.inferredClassSymbol || (links.inferredClassSymbol = ts.createMap())).set("" + getSymbolId(inferred), inferred); + return inferred; + } + return links.inferredClassSymbol.get("" + getSymbolId(target)); + } + } + function getAssignedClassSymbol(decl) { + var assignmentSymbol = decl && decl.parent && + (ts.isFunctionDeclaration(decl) && getSymbolOfNode(decl) || + ts.isBinaryExpression(decl.parent) && getSymbolOfNode(decl.parent.left) || + ts.isVariableDeclaration(decl.parent) && getSymbolOfNode(decl.parent)); + var prototype = assignmentSymbol && assignmentSymbol.exports && assignmentSymbol.exports.get("prototype"); + var init = prototype && prototype.valueDeclaration && getAssignedJSPrototype(prototype.valueDeclaration); + return init ? getSymbolOfNode(init) : undefined; + } + function getAssignedJSPrototype(node) { + if (!node.parent) { + return false; + } + var parent = node.parent; + while (parent && parent.kind === 194) { + parent = parent.parent; + } + if (parent && ts.isBinaryExpression(parent) && ts.isPrototypeAccess(parent.left) && parent.operatorToken.kind === 62) { + var right = ts.getInitializerOfBinaryExpression(parent); + return ts.isObjectLiteralExpression(right) && right; + } + } + function checkCallExpression(node, checkMode) { + if (!checkGrammarTypeArguments(node, node.typeArguments)) + checkGrammarArguments(node.arguments); + var signature = getResolvedSignature(node, undefined, checkMode); + if (signature === resolvingSignature) { + return nonInferrableType; + } + if (node.expression.kind === 102) { + return voidType; + } + if (node.kind === 197) { + var declaration = signature.declaration; + if (declaration && + declaration.kind !== 162 && + declaration.kind !== 166 && + declaration.kind !== 171 && + !ts.isJSDocConstructSignature(declaration) && + !isJSConstructor(declaration)) { + if (noImplicitAny) { + error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); + } + return anyType; + } + } + if (ts.isInJSFile(node) && isCommonJsRequire(node)) { + return resolveExternalModuleTypeByLiteral(node.arguments[0]); + } + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 12288 && isSymbolOrSymbolForCall(node)) { + return getESSymbolLikeTypeForNode(ts.walkUpParenthesizedExpressions(node.parent)); + } + if (node.kind === 196 && node.parent.kind === 226 && + returnType.flags & 16384 && getTypePredicateOfSignature(signature)) { + if (!ts.isDottedName(node.expression)) { + error(node.expression, ts.Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name); + } + else if (!getEffectsSignature(node)) { + var diagnostic = error(node.expression, ts.Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation); + getTypeOfDottedName(node.expression, diagnostic); + } + } + if (ts.isInJSFile(node)) { + var decl = ts.getDeclarationOfExpando(node); + if (decl) { + var jsSymbol = getSymbolOfNode(decl); + if (jsSymbol && ts.hasEntries(jsSymbol.exports)) { + var jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, ts.emptyArray, ts.emptyArray, undefined, undefined); + jsAssignmentType.objectFlags |= 16384; + return getIntersectionType([returnType, jsAssignmentType]); + } + } + } + return returnType; + } + function isSymbolOrSymbolForCall(node) { + if (!ts.isCallExpression(node)) + return false; + var left = node.expression; + if (ts.isPropertyAccessExpression(left) && left.name.escapedText === "for") { + left = left.expression; + } + if (!ts.isIdentifier(left) || left.escapedText !== "Symbol") { + return false; + } + var globalESSymbol = getGlobalESSymbolConstructorSymbol(false); + if (!globalESSymbol) { + return false; + } + return globalESSymbol === resolveName(left, "Symbol", 111551, undefined, undefined, false); + } + function checkImportCallExpression(node) { + if (!checkGrammarArguments(node.arguments)) + checkGrammarImportCallExpression(node); + if (node.arguments.length === 0) { + return createPromiseReturnType(node, anyType); + } + var specifier = node.arguments[0]; + var specifierType = checkExpressionCached(specifier); + for (var i = 1; i < node.arguments.length; ++i) { + checkExpressionCached(node.arguments[i]); + } + if (specifierType.flags & 32768 || specifierType.flags & 65536 || !isTypeAssignableTo(specifierType, stringType)) { + error(specifier, ts.Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType)); + } + var moduleSymbol = resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, false); + if (esModuleSymbol) { + return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol)); + } + } + return createPromiseReturnType(node, anyType); + } + function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) { + if (allowSyntheticDefaultImports && type && type !== errorType) { + var synthType = type; + if (!synthType.syntheticType) { + var file = ts.find(originalSymbol.declarations, ts.isSourceFile); + var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false); + if (hasSyntheticDefault) { + var memberTable = ts.createSymbolTable(); + var newSymbol = createSymbol(2097152, "default"); + newSymbol.nameType = getLiteralType("default"); + newSymbol.target = resolveSymbol(symbol); + memberTable.set("default", newSymbol); + var anonymousSymbol = createSymbol(2048, "__type"); + var defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, undefined, undefined); + anonymousSymbol.type = defaultContainingObject; + synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, 0, false) : defaultContainingObject; + } + else { + synthType.syntheticType = type; + } + } + return synthType.syntheticType; + } + return type; + } + function isCommonJsRequire(node) { + if (!ts.isRequireCall(node, true)) { + return false; + } + if (!ts.isIdentifier(node.expression)) + return ts.Debug.fail(); + var resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551, undefined, undefined, true); + if (resolvedRequire === requireSymbol) { + return true; + } + if (resolvedRequire.flags & 2097152) { + return false; + } + var targetDeclarationKind = resolvedRequire.flags & 16 + ? 244 + : resolvedRequire.flags & 3 + ? 242 + : 0; + if (targetDeclarationKind !== 0) { + var decl = ts.getDeclarationOfKind(resolvedRequire, targetDeclarationKind); + return !!decl && !!(decl.flags & 8388608); + } + return false; + } + function checkTaggedTemplateExpression(node) { + if (!checkGrammarTaggedTemplateChain(node)) + checkGrammarTypeArguments(node, node.typeArguments); + if (languageVersion < 2) { + checkExternalEmitHelpers(node, 131072); + } + return getReturnTypeOfSignature(getResolvedSignature(node)); + } + function checkAssertion(node) { + return checkAssertionWorker(node, node.type, node.expression); + } + function isValidConstAssertionArgument(node) { + switch (node.kind) { + case 10: + case 14: + case 8: + case 9: + case 106: + case 91: + case 192: + case 193: + return true; + case 200: + return isValidConstAssertionArgument(node.expression); + case 207: + var op = node.operator; + var arg = node.operand; + return op === 40 && (arg.kind === 8 || arg.kind === 9) || + op === 39 && arg.kind === 8; + case 194: + case 195: + var expr = node.expression; + if (ts.isIdentifier(expr)) { + var symbol = getSymbolAtLocation(expr); + if (symbol && symbol.flags & 2097152) { + symbol = resolveAlias(symbol); + } + return !!(symbol && (symbol.flags & 384) && getEnumKind(symbol) === 1); + } + } + return false; + } + function checkAssertionWorker(errNode, type, expression, checkMode) { + var exprType = checkExpression(expression, checkMode); + if (ts.isConstTypeReference(type)) { + if (!isValidConstAssertionArgument(expression)) { + error(expression, ts.Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals); + } + return getRegularTypeOfLiteralType(exprType); + } + checkSourceElement(type); + exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType)); + var targetType = getTypeFromTypeNode(type); + if (produceDiagnostics && targetType !== errorType) { + var widenedType = getWidenedType(exprType); + if (!isTypeComparableTo(targetType, widenedType)) { + checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first); + } + } + return targetType; + } + function checkNonNullAssertion(node) { + return getNonNullableType(checkExpression(node.expression)); + } + function checkMetaProperty(node) { + checkGrammarMetaProperty(node); + if (node.keywordToken === 99) { + return checkNewTargetMetaProperty(node); + } + if (node.keywordToken === 96) { + return checkImportMetaProperty(node); + } + return ts.Debug.assertNever(node.keywordToken); + } + function checkNewTargetMetaProperty(node) { + var container = ts.getNewTargetContainer(node); + if (!container) { + error(node, ts.Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target"); + return errorType; + } + else if (container.kind === 162) { + var symbol = getSymbolOfNode(container.parent); + return getTypeOfSymbol(symbol); + } + else { + var symbol = getSymbolOfNode(container); + return getTypeOfSymbol(symbol); + } + } + function checkImportMetaProperty(node) { + if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) { + error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system); + } + var file = ts.getSourceFileOfNode(node); + ts.Debug.assert(!!(file.flags & 2097152), "Containing file is missing import meta node flag."); + ts.Debug.assert(!!file.externalModuleIndicator, "Containing file should be a module."); + return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType; + } + function getTypeOfParameter(symbol) { + var type = getTypeOfSymbol(symbol); + if (strictNullChecks) { + var declaration = symbol.valueDeclaration; + if (declaration && ts.hasInitializer(declaration)) { + return getOptionalType(type); + } + } + return type; + } + function getParameterNameAtPosition(signature, pos) { + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + return signature.parameters[pos].escapedName; + } + var restParameter = signature.parameters[paramCount] || unknownSymbol; + var restType = getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + var associatedNames = restType.target.associatedNames; + var index = pos - paramCount; + return associatedNames && associatedNames[index] || restParameter.escapedName + "_" + index; + } + return restParameter.escapedName; + } + function getTypeAtPosition(signature, pos) { + return tryGetTypeAtPosition(signature, pos) || anyType; + } + function tryGetTypeAtPosition(signature, pos) { + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + return getTypeOfParameter(signature.parameters[pos]); + } + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[paramCount]); + var index = pos - paramCount; + if (!isTupleType(restType) || restType.target.hasRestElement || index < getTypeArguments(restType).length) { + return getIndexedAccessType(restType, getLiteralType(index)); + } + } + return undefined; + } + function getRestTypeAtPosition(source, pos) { + var paramCount = getParameterCount(source); + var restType = getEffectiveRestType(source); + var nonRestCount = paramCount - (restType ? 1 : 0); + if (restType && pos === nonRestCount) { + return restType; + } + var types = []; + var names = []; + for (var i = pos; i < nonRestCount; i++) { + types.push(getTypeAtPosition(source, i)); + names.push(getParameterNameAtPosition(source, i)); + } + if (restType) { + types.push(getIndexedAccessType(restType, numberType)); + names.push(getParameterNameAtPosition(source, nonRestCount)); + } + var minArgumentCount = getMinArgumentCount(source); + var minLength = minArgumentCount < pos ? 0 : minArgumentCount - pos; + return createTupleType(types, minLength, !!restType, false, names); + } + function getParameterCount(signature) { + var length = signature.parameters.length; + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[length - 1]); + if (isTupleType(restType)) { + return length + getTypeArguments(restType).length - 1; + } + } + return length; + } + function getMinArgumentCount(signature) { + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + if (isTupleType(restType)) { + var minLength = restType.target.minLength; + if (minLength > 0) { + return signature.parameters.length - 1 + minLength; + } + } + } + return signature.minArgumentCount; + } + function hasEffectiveRestParameter(signature) { + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + return !isTupleType(restType) || restType.target.hasRestElement; + } + return false; + } + function getEffectiveRestType(signature) { + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + return isTupleType(restType) ? getRestArrayTypeOfTupleType(restType) : restType; + } + return undefined; + } + function getNonArrayRestType(signature) { + var restType = getEffectiveRestType(signature); + return restType && !isArrayType(restType) && !isTypeAny(restType) ? restType : undefined; + } + function getTypeOfFirstParameterOfSignature(signature) { + return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType); + } + function getTypeOfFirstParameterOfSignatureWithFallback(signature, fallbackType) { + return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : fallbackType; + } + function inferFromAnnotatedParameters(signature, context, inferenceContext) { + var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + for (var i = 0; i < len; i++) { + var declaration = signature.parameters[i].valueDeclaration; + if (declaration.type) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode) { + inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i)); + } + } + } + var restType = getEffectiveRestType(context); + if (restType && restType.flags & 262144) { + var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper); + assignContextualParameterTypes(signature, instantiatedContext); + var restPos = getParameterCount(context) - 1; + inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType); + } + } + function assignContextualParameterTypes(signature, context) { + signature.typeParameters = context.typeParameters; + if (context.thisParameter) { + var parameter = signature.thisParameter; + if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) { + if (!parameter) { + signature.thisParameter = createSymbolWithType(context.thisParameter, undefined); + } + assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter)); + } + } + var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + for (var i = 0; i < len; i++) { + var parameter = signature.parameters[i]; + if (!ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) { + var contextualParameterType = tryGetTypeAtPosition(context, i); + assignParameterType(parameter, contextualParameterType); + } + } + if (signatureHasRestParameter(signature)) { + var parameter = ts.last(signature.parameters); + if (ts.isTransientSymbol(parameter) || !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) { + var contextualParameterType = getRestTypeAtPosition(context, len); + assignParameterType(parameter, contextualParameterType); + } + } + } + function assignNonContextualParameterTypes(signature) { + if (signature.thisParameter) { + assignParameterType(signature.thisParameter); + } + for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + assignParameterType(parameter); + } + } + function assignParameterType(parameter, type) { + var links = getSymbolLinks(parameter); + if (!links.type) { + var declaration = parameter.valueDeclaration; + links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, true); + if (declaration.name.kind !== 75) { + if (links.type === unknownType) { + links.type = getTypeFromBindingPattern(declaration.name); + } + assignBindingElementTypes(declaration.name); + } + } + } + function assignBindingElementTypes(pattern) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + if (element.name.kind === 75) { + getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element); + } + else { + assignBindingElementTypes(element.name); + } + } + } + } + function createPromiseType(promisedType) { + var globalPromiseType = getGlobalPromiseType(true); + if (globalPromiseType !== emptyGenericType) { + promisedType = getAwaitedType(promisedType) || unknownType; + return createTypeReference(globalPromiseType, [promisedType]); + } + return unknownType; + } + function createPromiseLikeType(promisedType) { + var globalPromiseLikeType = getGlobalPromiseLikeType(true); + if (globalPromiseLikeType !== emptyGenericType) { + promisedType = getAwaitedType(promisedType) || unknownType; + return createTypeReference(globalPromiseLikeType, [promisedType]); + } + return unknownType; + } + function createPromiseReturnType(func, promisedType) { + var promiseType = createPromiseType(promisedType); + if (promiseType === unknownType) { + error(func, ts.isImportCall(func) ? + ts.Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option : + ts.Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option); + return errorType; + } + else if (!getGlobalPromiseConstructorSymbol(true)) { + error(func, ts.isImportCall(func) ? + ts.Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option : + ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); + } + return promiseType; + } + function getReturnTypeFromBody(func, checkMode) { + if (!func.body) { + return errorType; + } + var functionFlags = ts.getFunctionFlags(func); + var isAsync = (functionFlags & 2) !== 0; + var isGenerator = (functionFlags & 1) !== 0; + var returnType; + var yieldType; + var nextType; + var fallbackReturnType = voidType; + if (func.body.kind !== 223) { + returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8); + if (isAsync) { + returnType = checkAwaitedType(returnType, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + } + else if (isGenerator) { + var returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode); + if (!returnTypes) { + fallbackReturnType = neverType; + } + else if (returnTypes.length > 0) { + returnType = getUnionType(returnTypes, 2); + } + var _a = checkAndAggregateYieldOperandTypes(func, checkMode), yieldTypes = _a.yieldTypes, nextTypes = _a.nextTypes; + yieldType = ts.some(yieldTypes) ? getUnionType(yieldTypes, 2) : undefined; + nextType = ts.some(nextTypes) ? getIntersectionType(nextTypes) : undefined; + } + else { + var types = checkAndAggregateReturnExpressionTypes(func, checkMode); + if (!types) { + return functionFlags & 2 + ? createPromiseReturnType(func, neverType) + : neverType; + } + if (types.length === 0) { + return functionFlags & 2 + ? createPromiseReturnType(func, voidType) + : voidType; + } + returnType = getUnionType(types, 2); + } + if (returnType || yieldType || nextType) { + var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); + if (!contextualSignature) { + if (yieldType) + reportErrorsFromWidening(func, yieldType, 1); + if (returnType) + reportErrorsFromWidening(func, returnType); + if (nextType) + reportErrorsFromWidening(func, nextType); + } + if (returnType && isUnitType(returnType) || + yieldType && isUnitType(yieldType) || + nextType && isUnitType(nextType)) { + var contextualType = !contextualSignature ? undefined : + contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType : + instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func); + if (isGenerator) { + yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0, isAsync); + returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1, isAsync); + nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2, isAsync); + } + else { + returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync); + } + } + if (yieldType) + yieldType = getWidenedType(yieldType); + if (returnType) + returnType = getWidenedType(returnType); + if (nextType) + nextType = getWidenedType(nextType); + } + if (isGenerator) { + return createGeneratorReturnType(yieldType || neverType, returnType || fallbackReturnType, nextType || getContextualIterationType(2, func) || unknownType, isAsync); + } + else { + return isAsync + ? createPromiseType(returnType || fallbackReturnType) + : returnType || fallbackReturnType; + } + } + function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) { + var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver; + var globalGeneratorType = resolver.getGlobalGeneratorType(false); + yieldType = resolver.resolveIterationType(yieldType, undefined) || unknownType; + returnType = resolver.resolveIterationType(returnType, undefined) || unknownType; + nextType = resolver.resolveIterationType(nextType, undefined) || unknownType; + if (globalGeneratorType === emptyGenericType) { + var globalType = resolver.getGlobalIterableIteratorType(false); + var iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : undefined; + var iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType; + var iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType; + if (isTypeAssignableTo(returnType, iterableIteratorReturnType) && + isTypeAssignableTo(iterableIteratorNextType, nextType)) { + if (globalType !== emptyGenericType) { + return createTypeFromGenericGlobalType(globalType, [yieldType]); + } + resolver.getGlobalIterableIteratorType(true); + return emptyObjectType; + } + resolver.getGlobalGeneratorType(true); + return emptyObjectType; + } + return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]); + } + function checkAndAggregateYieldOperandTypes(func, checkMode) { + var yieldTypes = []; + var nextTypes = []; + var isAsync = (ts.getFunctionFlags(func) & 2) !== 0; + ts.forEachYieldExpression(func.body, function (yieldExpression) { + var yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType; + ts.pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync)); + var nextType; + if (yieldExpression.asteriskToken) { + var iterationTypes = getIterationTypesOfIterable(yieldExpressionType, isAsync ? 19 : 17, yieldExpression.expression); + nextType = iterationTypes && iterationTypes.nextType; + } + else { + nextType = getContextualType(yieldExpression); + } + if (nextType) + ts.pushIfUnique(nextTypes, nextType); + }); + return { yieldTypes: yieldTypes, nextTypes: nextTypes }; + } + function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) { + var errorNode = node.expression || node; + var yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 : 17, expressionType, sentType, errorNode) : expressionType; + return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken + ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + function getFactsFromTypeofSwitch(start, end, witnesses, hasDefault) { + var facts = 0; + if (hasDefault) { + for (var i = end; i < witnesses.length; i++) { + facts |= typeofNEFacts.get(witnesses[i]) || 32768; + } + for (var i = start; i < end; i++) { + facts &= ~(typeofNEFacts.get(witnesses[i]) || 0); + } + for (var i = 0; i < start; i++) { + facts |= typeofNEFacts.get(witnesses[i]) || 32768; + } + } + else { + for (var i = start; i < end; i++) { + facts |= typeofEQFacts.get(witnesses[i]) || 128; + } + for (var i = 0; i < start; i++) { + facts &= ~(typeofEQFacts.get(witnesses[i]) || 0); + } + } + return facts; + } + function isExhaustiveSwitchStatement(node) { + var links = getNodeLinks(node); + return links.isExhaustive !== undefined ? links.isExhaustive : (links.isExhaustive = computeExhaustiveSwitchStatement(node)); + } + function computeExhaustiveSwitchStatement(node) { + if (node.expression.kind === 204) { + var operandType = getTypeOfExpression(node.expression.expression); + var witnesses = getSwitchClauseTypeOfWitnesses(node); + var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, true); + var type_3 = getBaseConstraintOfType(operandType) || operandType; + return !!(filterType(type_3, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072); + } + var type = getTypeOfExpression(node.expression); + if (!isLiteralType(type)) { + return false; + } + var switchTypes = getSwitchClauseTypes(node); + if (!switchTypes.length || ts.some(switchTypes, isNeitherUnitTypeNorNever)) { + return false; + } + return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes); + } + function functionHasImplicitReturn(func) { + return func.endFlowNode && isReachableFlowNode(func.endFlowNode); + } + function checkAndAggregateReturnExpressionTypes(func, checkMode) { + var functionFlags = ts.getFunctionFlags(func); + var aggregatedTypes = []; + var hasReturnWithNoExpression = functionHasImplicitReturn(func); + var hasReturnOfTypeNever = false; + ts.forEachReturnStatement(func.body, function (returnStatement) { + var expr = returnStatement.expression; + if (expr) { + var type = checkExpressionCached(expr, checkMode && checkMode & ~8); + if (functionFlags & 2) { + type = checkAwaitedType(type, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + if (type.flags & 131072) { + hasReturnOfTypeNever = true; + } + ts.pushIfUnique(aggregatedTypes, type); + } + else { + hasReturnWithNoExpression = true; + } + }); + if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) { + return undefined; + } + if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression && + !(isJSConstructor(func) && aggregatedTypes.some(function (t) { return t.symbol === func.symbol; }))) { + ts.pushIfUnique(aggregatedTypes, undefinedType); + } + return aggregatedTypes; + } + function mayReturnNever(func) { + switch (func.kind) { + case 201: + case 202: + return true; + case 161: + return func.parent.kind === 193; + default: + return false; + } + } + function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) { + if (!produceDiagnostics) { + return; + } + var functionFlags = ts.getFunctionFlags(func); + var type = returnType && getReturnOrPromisedType(returnType, functionFlags); + if (type && maybeTypeOfKind(type, 1 | 16384)) { + return; + } + if (func.kind === 160 || ts.nodeIsMissing(func.body) || func.body.kind !== 223 || !functionHasImplicitReturn(func)) { + return; + } + var hasExplicitReturn = func.flags & 512; + if (type && type.flags & 131072) { + error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point); + } + else if (type && !hasExplicitReturn) { + error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value); + } + else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) { + error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined); + } + else if (compilerOptions.noImplicitReturns) { + if (!type) { + if (!hasExplicitReturn) { + return; + } + var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) { + return; + } + } + error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Not_all_code_paths_return_a_value); + } + } + function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) { + ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node)); + checkNodeDeferred(node); + if (checkMode && checkMode & 4 && isContextSensitive(node)) { + if (!ts.getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) { + var contextualSignature = getContextualSignature(node); + if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) { + var links = getNodeLinks(node); + if (links.contextFreeType) { + return links.contextFreeType; + } + var returnType = getReturnTypeFromBody(node, checkMode); + var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, undefined, 0, 0); + var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined); + returnOnlyType.objectFlags |= 2097152; + return links.contextFreeType = returnOnlyType; + } + } + return anyFunctionType; + } + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 201) { + checkGrammarForGenerator(node); + } + contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode); + return getTypeOfSymbol(getSymbolOfNode(node)); + } + function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) { + var links = getNodeLinks(node); + if (!(links.flags & 1024)) { + var contextualSignature = getContextualSignature(node); + if (!(links.flags & 1024)) { + links.flags |= 1024; + var signature = ts.firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0)); + if (!signature) { + return; + } + if (isContextSensitive(node)) { + if (contextualSignature) { + var inferenceContext = getInferenceContext(node); + if (checkMode && checkMode & 2) { + inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext); + } + var instantiatedContextualSignature = inferenceContext ? + instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature; + assignContextualParameterTypes(signature, instantiatedContextualSignature); + } + else { + assignNonContextualParameterTypes(signature); + } + } + if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) { + var returnType = getReturnTypeFromBody(node, checkMode); + if (!signature.resolvedReturnType) { + signature.resolvedReturnType = returnType; + } + } + checkSignatureDeclaration(node); + } + } + } + function getReturnOrPromisedType(type, functionFlags) { + var isGenerator = !!(functionFlags & 1); + var isAsync = !!(functionFlags & 2); + return type && isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(1, type, isAsync) || errorType : + type && isAsync ? getAwaitedType(type) || errorType : + type; + } + function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) { + ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node)); + var functionFlags = ts.getFunctionFlags(node); + var returnType = getReturnTypeFromAnnotation(node); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType); + if (node.body) { + if (!ts.getEffectiveReturnTypeNode(node)) { + getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } + if (node.body.kind === 223) { + checkSourceElement(node.body); + } + else { + var exprType = checkExpression(node.body); + var returnOrPromisedType = getReturnOrPromisedType(returnType, functionFlags); + if (returnOrPromisedType) { + if ((functionFlags & 3) === 2) { + var awaitedType = checkAwaitedType(exprType, node.body, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, node.body, node.body); + } + else { + checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body); + } + } + } + } + } + function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid) { + if (isAwaitValid === void 0) { isAwaitValid = false; } + if (!isTypeAssignableTo(type, numberOrBigIntType)) { + var awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type); + errorAndMaybeSuggestAwait(operand, !!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType), diagnostic); + return false; + } + return true; + } + function isReadonlyAssignmentDeclaration(d) { + if (!ts.isCallExpression(d)) { + return false; + } + if (!ts.isBindableObjectDefinePropertyCall(d)) { + return false; + } + var objectLitType = checkExpressionCached(d.arguments[2]); + var valueType = getTypeOfPropertyOfType(objectLitType, "value"); + if (valueType) { + var writableProp = getPropertyOfType(objectLitType, "writable"); + var writableType = writableProp && getTypeOfSymbol(writableProp); + if (!writableType || writableType === falseType || writableType === regularFalseType) { + return true; + } + if (writableProp && writableProp.valueDeclaration && ts.isPropertyAssignment(writableProp.valueDeclaration)) { + var initializer = writableProp.valueDeclaration.initializer; + var rawOriginalType = checkExpression(initializer); + if (rawOriginalType === falseType || rawOriginalType === regularFalseType) { + return true; + } + } + return false; + } + var setProp = getPropertyOfType(objectLitType, "set"); + return !setProp; + } + function isReadonlySymbol(symbol) { + return !!(ts.getCheckFlags(symbol) & 8 || + symbol.flags & 4 && ts.getDeclarationModifierFlagsFromSymbol(symbol) & 64 || + symbol.flags & 3 && getDeclarationNodeFlagsFromSymbol(symbol) & 2 || + symbol.flags & 98304 && !(symbol.flags & 65536) || + symbol.flags & 8 || + ts.some(symbol.declarations, isReadonlyAssignmentDeclaration)); + } + function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) { + var _a, _b; + if (assignmentKind === 0) { + return false; + } + if (isReadonlySymbol(symbol)) { + if (symbol.flags & 4 && + ts.isAccessExpression(expr) && + expr.expression.kind === 104) { + var ctor = ts.getContainingFunction(expr); + if (!(ctor && ctor.kind === 162)) { + return true; + } + if (symbol.valueDeclaration) { + var isAssignmentDeclaration_1 = ts.isBinaryExpression(symbol.valueDeclaration); + var isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent; + var isLocalParameterProperty = ctor === symbol.valueDeclaration.parent; + var isLocalThisPropertyAssignment = isAssignmentDeclaration_1 && ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === ctor.parent; + var isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration_1 && ((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration) === ctor; + var isWriteableSymbol = isLocalPropertyDeclaration + || isLocalParameterProperty + || isLocalThisPropertyAssignment + || isLocalThisPropertyAssignmentConstructorFunction; + return !isWriteableSymbol; + } + } + return true; + } + if (ts.isAccessExpression(expr)) { + var node = ts.skipParentheses(expr.expression); + if (node.kind === 75) { + var symbol_2 = getNodeLinks(node).resolvedSymbol; + if (symbol_2.flags & 2097152) { + var declaration = getDeclarationOfAliasSymbol(symbol_2); + return !!declaration && declaration.kind === 256; + } + } + } + return false; + } + function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) { + var node = ts.skipOuterExpressions(expr, 2 | 1); + if (node.kind !== 75 && !ts.isAccessExpression(node)) { + error(expr, invalidReferenceMessage); + return false; + } + if (node.flags & 32) { + error(expr, invalidOptionalChainMessage); + return false; + } + return true; + } + function checkDeleteExpression(node) { + checkExpression(node.expression); + var expr = ts.skipParentheses(node.expression); + if (!ts.isAccessExpression(expr)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference); + return booleanType; + } + if (expr.kind === 194 && ts.isPrivateIdentifier(expr.name)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier); + } + var links = getNodeLinks(expr); + var symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol); + if (symbol && isReadonlySymbol(symbol)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); + } + return booleanType; + } + function checkTypeOfExpression(node) { + checkExpression(node.expression); + return typeofType; + } + function checkVoidExpression(node) { + checkExpression(node.expression); + return undefinedWideningType; + } + function isTopLevelAwait(node) { + var container = ts.getThisContainer(node, true); + return ts.isSourceFile(container); + } + function checkAwaitExpression(node) { + if (produceDiagnostics) { + if (!(node.flags & 32768)) { + if (isTopLevelAwait(node)) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = void 0; + if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + if (!span) + span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module); + diagnostics.add(diagnostic); + } + if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) || languageVersion < 4) { + span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher); + diagnostics.add(diagnostic); + } + } + } + else { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules); + var func = ts.getContainingFunction(node); + if (func && func.kind !== 162 && (ts.getFunctionFlags(func) & 2) === 0) { + var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); + ts.addRelatedInfo(diagnostic, relatedInfo); + } + diagnostics.add(diagnostic); + } + } + } + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer); + } + } + var operandType = checkExpression(node.expression); + var awaitedType = checkAwaitedType(operandType, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + if (awaitedType === operandType && awaitedType !== errorType && !(operandType.flags & 3)) { + addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression)); + } + return awaitedType; + } + function checkPrefixUnaryExpression(node) { + var operandType = checkExpression(node.operand); + if (operandType === silentNeverType) { + return silentNeverType; + } + switch (node.operand.kind) { + case 8: + switch (node.operator) { + case 40: + return getFreshTypeOfLiteralType(getLiteralType(-node.operand.text)); + case 39: + return getFreshTypeOfLiteralType(getLiteralType(+node.operand.text)); + } + break; + case 9: + if (node.operator === 40) { + return getFreshTypeOfLiteralType(getLiteralType({ + negative: true, + base10Value: ts.parsePseudoBigInt(node.operand.text) + })); + } + } + switch (node.operator) { + case 39: + case 40: + case 54: + checkNonNullType(operandType, node.operand); + if (maybeTypeOfKind(operandType, 12288)) { + error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator)); + } + if (node.operator === 39) { + if (maybeTypeOfKind(operandType, 2112)) { + error(node.operand, ts.Diagnostics.Operator_0_cannot_be_applied_to_type_1, ts.tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType))); + } + return numberType; + } + return getUnaryResultType(operandType); + case 53: + checkTruthinessExpression(node.operand); + var facts = getTypeFacts(operandType) & (4194304 | 8388608); + return facts === 4194304 ? falseType : + facts === 8388608 ? trueType : + booleanType; + case 45: + case 46: + var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type); + if (ok) { + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access); + } + return getUnaryResultType(operandType); + } + return errorType; + } + function checkPostfixUnaryExpression(node) { + var operandType = checkExpression(node.operand); + if (operandType === silentNeverType) { + return silentNeverType; + } + var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type); + if (ok) { + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access); + } + return getUnaryResultType(operandType); + } + function getUnaryResultType(operandType) { + if (maybeTypeOfKind(operandType, 2112)) { + return isTypeAssignableToKind(operandType, 3) || maybeTypeOfKind(operandType, 296) + ? numberOrBigIntType + : bigintType; + } + return numberType; + } + function maybeTypeOfKind(type, kind) { + if (type.flags & kind & ~131072 || kind & 131072 && isGenericMappedType(type)) { + return true; + } + if (type.flags & 3145728) { + var types = type.types; + for (var _i = 0, types_18 = types; _i < types_18.length; _i++) { + var t = types_18[_i]; + if (maybeTypeOfKind(t, kind)) { + return true; + } + } + } + return false; + } + function isTypeAssignableToKind(source, kind, strict) { + if (source.flags & kind) { + return true; + } + if (strict && source.flags & (3 | 16384 | 32768 | 65536)) { + return false; + } + return !!(kind & 296) && isTypeAssignableTo(source, numberType) || + !!(kind & 2112) && isTypeAssignableTo(source, bigintType) || + !!(kind & 132) && isTypeAssignableTo(source, stringType) || + !!(kind & 528) && isTypeAssignableTo(source, booleanType) || + !!(kind & 16384) && isTypeAssignableTo(source, voidType) || + !!(kind & 131072) && isTypeAssignableTo(source, neverType) || + !!(kind & 65536) && isTypeAssignableTo(source, nullType) || + !!(kind & 32768) && isTypeAssignableTo(source, undefinedType) || + !!(kind & 4096) && isTypeAssignableTo(source, esSymbolType) || + !!(kind & 67108864) && isTypeAssignableTo(source, nonPrimitiveType); + } + function allTypesAssignableToKind(source, kind, strict) { + return source.flags & 1048576 ? + ts.every(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) : + isTypeAssignableToKind(source, kind, strict); + } + function isConstEnumObjectType(type) { + return !!(ts.getObjectFlags(type) & 16) && !!type.symbol && isConstEnumSymbol(type.symbol); + } + function isConstEnumSymbol(symbol) { + return (symbol.flags & 128) !== 0; + } + function checkInstanceOfExpression(left, right, leftType, rightType) { + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + if (!isTypeAny(leftType) && + allTypesAssignableToKind(leftType, 131068)) { + error(left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) { + error(right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); + } + return booleanType; + } + function checkInExpression(left, right, leftType, rightType) { + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + leftType = checkNonNullType(leftType, left); + rightType = checkNonNullType(rightType, right); + if (!(isTypeComparableTo(leftType, stringType) || isTypeAssignableToKind(leftType, 296 | 12288))) { + error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); + } + if (!allTypesAssignableToKind(rightType, 67108864 | 58982400)) { + error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + return booleanType; + } + function checkObjectLiteralAssignment(node, sourceType, rightIsThis) { + var properties = node.properties; + if (strictNullChecks && properties.length === 0) { + return checkNonNullType(sourceType, node); + } + for (var i = 0; i < properties.length; i++) { + checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis); + } + return sourceType; + } + function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis) { + if (rightIsThis === void 0) { rightIsThis = false; } + var properties = node.properties; + var property = properties[propertyIndex]; + if (property.kind === 281 || property.kind === 282) { + var name = property.name; + var exprType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(exprType)) { + var text = getPropertyNameFromType(exprType); + var prop = getPropertyOfType(objectLiteralType, text); + if (prop) { + markPropertyAsReferenced(prop, property, rightIsThis); + checkPropertyAccessibility(property, false, objectLiteralType, prop); + } + } + var elementType = getIndexedAccessType(objectLiteralType, exprType, name); + var type = getFlowTypeOfDestructuring(property, elementType); + return checkDestructuringAssignment(property.kind === 282 ? property : property.initializer, type); + } + else if (property.kind === 283) { + if (propertyIndex < properties.length - 1) { + error(property, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + else { + if (languageVersion < 99) { + checkExternalEmitHelpers(property, 4); + } + var nonRestNames = []; + if (allProperties) { + for (var _i = 0, allProperties_1 = allProperties; _i < allProperties_1.length; _i++) { + var otherProperty = allProperties_1[_i]; + if (!ts.isSpreadAssignment(otherProperty)) { + nonRestNames.push(otherProperty.name); + } + } + } + var type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol); + checkGrammarForDisallowedTrailingComma(allProperties, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + return checkDestructuringAssignment(property.expression, type); + } + } + else { + error(property, ts.Diagnostics.Property_assignment_expected); + } + } + function checkArrayLiteralAssignment(node, sourceType, checkMode) { + var elements = node.elements; + if (languageVersion < 2 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 512); + } + var elementType = checkIteratedTypeOrElementType(65, sourceType, undefinedType, node) || errorType; + for (var i = 0; i < elements.length; i++) { + checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, elementType, checkMode); + } + return sourceType; + } + function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) { + var elements = node.elements; + var element = elements[elementIndex]; + if (element.kind !== 215) { + if (element.kind !== 213) { + var indexType = getLiteralType(elementIndex); + if (isArrayLikeType(sourceType)) { + var accessFlags = hasDefaultValue(element) ? 8 : 0; + var elementType_2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, createSyntheticExpression(element, indexType), accessFlags) || errorType; + var assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType_2, 524288) : elementType_2; + var type = getFlowTypeOfDestructuring(element, assignedType); + return checkDestructuringAssignment(element, type, checkMode); + } + return checkDestructuringAssignment(element, elementType, checkMode); + } + if (elementIndex < elements.length - 1) { + error(element, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + else { + var restExpression = element.expression; + if (restExpression.kind === 209 && restExpression.operatorToken.kind === 62) { + error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); + } + else { + checkGrammarForDisallowedTrailingComma(node.elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + var type = everyType(sourceType, isTupleType) ? + mapType(sourceType, function (t) { return sliceTupleType(t, elementIndex); }) : + createArrayType(elementType); + return checkDestructuringAssignment(restExpression, type, checkMode); + } + } + } + return undefined; + } + function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) { + var target; + if (exprOrAssignment.kind === 282) { + var prop = exprOrAssignment; + if (prop.objectAssignmentInitializer) { + if (strictNullChecks && + !(getFalsyFlags(checkExpression(prop.objectAssignmentInitializer)) & 32768)) { + sourceType = getTypeWithFacts(sourceType, 524288); + } + checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode); + } + target = exprOrAssignment.name; + } + else { + target = exprOrAssignment; + } + if (target.kind === 209 && target.operatorToken.kind === 62) { + checkBinaryExpression(target, checkMode); + target = target.left; + } + if (target.kind === 193) { + return checkObjectLiteralAssignment(target, sourceType, rightIsThis); + } + if (target.kind === 192) { + return checkArrayLiteralAssignment(target, sourceType, checkMode); + } + return checkReferenceAssignment(target, sourceType, checkMode); + } + function checkReferenceAssignment(target, sourceType, checkMode) { + var targetType = checkExpression(target, checkMode); + var error = target.parent.kind === 283 ? + ts.Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access : + ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access; + var optionalError = target.parent.kind === 283 ? + ts.Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access : + ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access; + if (checkReferenceExpression(target, error, optionalError)) { + checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target); + } + if (ts.isPrivateIdentifierPropertyAccessExpression(target)) { + checkExternalEmitHelpers(target.parent, 524288); + } + return sourceType; + } + function isSideEffectFree(node) { + node = ts.skipParentheses(node); + switch (node.kind) { + case 75: + case 10: + case 13: + case 198: + case 211: + case 14: + case 8: + case 9: + case 106: + case 91: + case 100: + case 146: + case 201: + case 214: + case 202: + case 192: + case 193: + case 204: + case 218: + case 267: + case 266: + return true; + case 210: + return isSideEffectFree(node.whenTrue) && + isSideEffectFree(node.whenFalse); + case 209: + if (ts.isAssignmentOperator(node.operatorToken.kind)) { + return false; + } + return isSideEffectFree(node.left) && + isSideEffectFree(node.right); + case 207: + case 208: + switch (node.operator) { + case 53: + case 39: + case 40: + case 54: + return true; + } + return false; + case 205: + case 199: + case 217: + default: + return false; + } + } + function isTypeEqualityComparableTo(source, target) { + return (target.flags & 98304) !== 0 || isTypeComparableTo(source, target); + } + function checkBinaryExpression(node, checkMode) { + var workStacks = { + expr: [node], + state: [0], + leftType: [undefined] + }; + var stackIndex = 0; + var lastResult; + while (stackIndex >= 0) { + node = workStacks.expr[stackIndex]; + switch (workStacks.state[stackIndex]) { + case 0: { + if (ts.isInJSFile(node) && ts.getAssignedExpandoInitializer(node)) { + finishInvocation(checkExpression(node.right, checkMode)); + break; + } + checkGrammarNullishCoalesceWithLogicalExpression(node); + var operator = node.operatorToken.kind; + if (operator === 62 && (node.left.kind === 193 || node.left.kind === 192)) { + finishInvocation(checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 104)); + break; + } + advanceState(1); + maybeCheckExpression(node.left); + break; + } + case 1: { + var leftType = lastResult; + workStacks.leftType[stackIndex] = leftType; + var operator = node.operatorToken.kind; + if (operator === 55 || operator === 56 || operator === 60) { + checkTruthinessOfType(leftType, node.left); + } + advanceState(2); + maybeCheckExpression(node.right); + break; + } + case 2: { + var leftType = workStacks.leftType[stackIndex]; + var rightType = lastResult; + finishInvocation(checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node)); + break; + } + default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for checkBinaryExpression"); + } + } + return lastResult; + function finishInvocation(result) { + lastResult = result; + stackIndex--; + } + function advanceState(nextState) { + workStacks.state[stackIndex] = nextState; + } + function maybeCheckExpression(node) { + if (ts.isBinaryExpression(node)) { + stackIndex++; + workStacks.expr[stackIndex] = node; + workStacks.state[stackIndex] = 0; + workStacks.leftType[stackIndex] = undefined; + } + else { + lastResult = checkExpression(node, checkMode); + } + } + } + function checkGrammarNullishCoalesceWithLogicalExpression(node) { + var left = node.left, operatorToken = node.operatorToken, right = node.right; + if (operatorToken.kind === 60) { + if (ts.isBinaryExpression(left) && (left.operatorToken.kind === 56 || left.operatorToken.kind === 55)) { + grammarErrorOnNode(left, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(left.operatorToken.kind), ts.tokenToString(operatorToken.kind)); + } + if (ts.isBinaryExpression(right) && (right.operatorToken.kind === 56 || right.operatorToken.kind === 55)) { + grammarErrorOnNode(right, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(right.operatorToken.kind), ts.tokenToString(operatorToken.kind)); + } + } + } + function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) { + var operator = operatorToken.kind; + if (operator === 62 && (left.kind === 193 || left.kind === 192)) { + return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 104); + } + var leftType; + if (operator === 55 || operator === 56 || operator === 60) { + leftType = checkTruthinessExpression(left, checkMode); + } + else { + leftType = checkExpression(left, checkMode); + } + var rightType = checkExpression(right, checkMode); + return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode); + } + function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) { + var operator = operatorToken.kind; + switch (operator) { + case 41: + case 42: + case 65: + case 66: + case 43: + case 67: + case 44: + case 68: + case 40: + case 64: + case 47: + case 69: + case 48: + case 70: + case 49: + case 71: + case 51: + case 73: + case 52: + case 74: + case 50: + case 72: + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + leftType = checkNonNullType(leftType, left); + rightType = checkNonNullType(rightType, right); + var suggestedOperator = void 0; + if ((leftType.flags & 528) && + (rightType.flags & 528) && + (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) { + error(errorNode || operatorToken, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(operatorToken.kind), ts.tokenToString(suggestedOperator)); + return numberType; + } + else { + var leftOk = checkArithmeticOperandType(left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true); + var rightOk = checkArithmeticOperandType(right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true); + var resultType_1; + if ((isTypeAssignableToKind(leftType, 3) && isTypeAssignableToKind(rightType, 3)) || + !(maybeTypeOfKind(leftType, 2112) || maybeTypeOfKind(rightType, 2112))) { + resultType_1 = numberType; + } + else if (bothAreBigIntLike(leftType, rightType)) { + switch (operator) { + case 49: + case 71: + reportOperatorError(); + } + resultType_1 = bigintType; + } + else { + reportOperatorError(bothAreBigIntLike); + resultType_1 = errorType; + } + if (leftOk && rightOk) { + checkAssignmentOperator(resultType_1); + } + return resultType_1; + } + case 39: + case 63: + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + if (!isTypeAssignableToKind(leftType, 132) && !isTypeAssignableToKind(rightType, 132)) { + leftType = checkNonNullType(leftType, left); + rightType = checkNonNullType(rightType, right); + } + var resultType = void 0; + if (isTypeAssignableToKind(leftType, 296, true) && isTypeAssignableToKind(rightType, 296, true)) { + resultType = numberType; + } + else if (isTypeAssignableToKind(leftType, 2112, true) && isTypeAssignableToKind(rightType, 2112, true)) { + resultType = bigintType; + } + else if (isTypeAssignableToKind(leftType, 132, true) || isTypeAssignableToKind(rightType, 132, true)) { + resultType = stringType; + } + else if (isTypeAny(leftType) || isTypeAny(rightType)) { + resultType = leftType === errorType || rightType === errorType ? errorType : anyType; + } + if (resultType && !checkForDisallowedESSymbolOperand(operator)) { + return resultType; + } + if (!resultType) { + var closeEnoughKind_1 = 296 | 2112 | 132 | 3; + reportOperatorError(function (left, right) { + return isTypeAssignableToKind(left, closeEnoughKind_1) && + isTypeAssignableToKind(right, closeEnoughKind_1); + }); + return anyType; + } + if (operator === 63) { + checkAssignmentOperator(resultType); + } + return resultType; + case 29: + case 31: + case 32: + case 33: + if (checkForDisallowedESSymbolOperand(operator)) { + leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left)); + rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right)); + reportOperatorErrorUnless(function (left, right) { + return isTypeComparableTo(left, right) || isTypeComparableTo(right, left) || (isTypeAssignableTo(left, numberOrBigIntType) && isTypeAssignableTo(right, numberOrBigIntType)); + }); + } + return booleanType; + case 34: + case 35: + case 36: + case 37: + reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); }); + return booleanType; + case 98: + return checkInstanceOfExpression(left, right, leftType, rightType); + case 97: + return checkInExpression(left, right, leftType, rightType); + case 55: + return getTypeFacts(leftType) & 4194304 ? + getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : + leftType; + case 56: + return getTypeFacts(leftType) & 8388608 ? + getUnionType([removeDefinitelyFalsyTypes(leftType), rightType], 2) : + leftType; + case 60: + return getTypeFacts(leftType) & 262144 ? + getUnionType([getNonNullableType(leftType), rightType], 2) : + leftType; + case 62: + var declKind = ts.isBinaryExpression(left.parent) ? ts.getAssignmentDeclarationKind(left.parent) : 0; + checkAssignmentDeclaration(declKind, rightType); + if (isAssignmentDeclaration(declKind)) { + if (!(rightType.flags & 524288) || + declKind !== 2 && + declKind !== 6 && + !isEmptyObjectType(rightType) && + !isFunctionObjectType(rightType) && + !(ts.getObjectFlags(rightType) & 1)) { + checkAssignmentOperator(rightType); + } + return leftType; + } + else { + checkAssignmentOperator(rightType); + return getRegularTypeOfObjectLiteral(rightType); + } + case 27: + if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) { + error(left, ts.Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects); + } + return rightType; + default: + return ts.Debug.fail(); + } + function bothAreBigIntLike(left, right) { + return isTypeAssignableToKind(left, 2112) && isTypeAssignableToKind(right, 2112); + } + function checkAssignmentDeclaration(kind, rightType) { + if (kind === 2) { + for (var _i = 0, _a = getPropertiesOfObjectType(rightType); _i < _a.length; _i++) { + var prop = _a[_i]; + var propType = getTypeOfSymbol(prop); + if (propType.symbol && propType.symbol.flags & 32) { + var name = prop.escapedName; + var symbol = resolveName(prop.valueDeclaration, name, 788968, undefined, name, false); + if (symbol && symbol.declarations.some(ts.isJSDocTypedefTag)) { + grammarErrorOnNode(symbol.declarations[0], ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name)); + return grammarErrorOnNode(prop.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name)); + } + } + } + } + } + function isEvalNode(node) { + return node.kind === 75 && node.escapedText === "eval"; + } + function checkForDisallowedESSymbolOperand(operator) { + var offendingSymbolOperand = maybeTypeOfKind(leftType, 12288) ? left : + maybeTypeOfKind(rightType, 12288) ? right : + undefined; + if (offendingSymbolOperand) { + error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator)); + return false; + } + return true; + } + function getSuggestedBooleanOperator(operator) { + switch (operator) { + case 51: + case 73: + return 56; + case 52: + case 74: + return 37; + case 50: + case 72: + return 55; + default: + return undefined; + } + } + function checkAssignmentOperator(valueType) { + if (produceDiagnostics && ts.isAssignmentOperator(operator)) { + if (checkReferenceExpression(left, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access) + && (!ts.isIdentifier(left) || ts.unescapeLeadingUnderscores(left.escapedText) !== "exports")) { + checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right); + } + } + } + function isAssignmentDeclaration(kind) { + switch (kind) { + case 2: + return true; + case 1: + case 5: + case 6: + case 3: + case 4: + var symbol = getSymbolOfNode(left); + var init = ts.getAssignedExpandoInitializer(right); + return init && ts.isObjectLiteralExpression(init) && + symbol && ts.hasEntries(symbol.exports); + default: + return false; + } + } + function reportOperatorErrorUnless(typesAreCompatible) { + if (!typesAreCompatible(leftType, rightType)) { + reportOperatorError(typesAreCompatible); + return true; + } + return false; + } + function reportOperatorError(isRelated) { + var _a; + var wouldWorkWithAwait = false; + var errNode = errorNode || operatorToken; + if (isRelated) { + var awaitedLeftType = getAwaitedType(leftType); + var awaitedRightType = getAwaitedType(rightType); + wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType) + && !!(awaitedLeftType && awaitedRightType) + && isRelated(awaitedLeftType, awaitedRightType); + } + var effectiveLeft = leftType; + var effectiveRight = rightType; + if (!wouldWorkWithAwait && isRelated) { + _a = getBaseTypesIfUnrelated(leftType, rightType, isRelated), effectiveLeft = _a[0], effectiveRight = _a[1]; + } + var _b = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight), leftStr = _b[0], rightStr = _b[1]; + if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) { + errorAndMaybeSuggestAwait(errNode, wouldWorkWithAwait, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), leftStr, rightStr); + } + } + function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) { + var typeName; + switch (operatorToken.kind) { + case 36: + case 34: + typeName = "false"; + break; + case 37: + case 35: + typeName = "true"; + } + if (typeName) { + return errorAndMaybeSuggestAwait(errNode, maybeMissingAwait, ts.Diagnostics.This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap, typeName, leftStr, rightStr); + } + return undefined; + } + } + function getBaseTypesIfUnrelated(leftType, rightType, isRelated) { + var effectiveLeft = leftType; + var effectiveRight = rightType; + var leftBase = getBaseTypeOfLiteralType(leftType); + var rightBase = getBaseTypeOfLiteralType(rightType); + if (!isRelated(leftBase, rightBase)) { + effectiveLeft = leftBase; + effectiveRight = rightBase; + } + return [effectiveLeft, effectiveRight]; + } + function checkYieldExpression(node) { + if (produceDiagnostics) { + if (!(node.flags & 8192)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body); + } + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer); + } + } + var func = ts.getContainingFunction(node); + if (!func) + return anyType; + var functionFlags = ts.getFunctionFlags(func); + if (!(functionFlags & 1)) { + return anyType; + } + var isAsync = (functionFlags & 2) !== 0; + if (node.asteriskToken) { + if (isAsync && languageVersion < 99) { + checkExternalEmitHelpers(node, 53248); + } + if (!isAsync && languageVersion < 2 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 256); + } + } + var returnType = getReturnTypeFromAnnotation(func); + var iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync); + var signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType; + var signatureNextType = iterationTypes && iterationTypes.nextType || anyType; + var resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType; + var yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType; + var yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync); + if (returnType && yieldedType) { + checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression); + } + if (node.asteriskToken) { + var use = isAsync ? 19 : 17; + return getIterationTypeOfIterable(use, 1, yieldExpressionType, node.expression) + || anyType; + } + else if (returnType) { + return getIterationTypeOfGeneratorFunctionReturnType(2, returnType, isAsync) + || anyType; + } + return getContextualIterationType(2, func) || anyType; + } + function checkConditionalExpression(node, checkMode) { + checkTruthinessExpression(node.condition); + var type1 = checkExpression(node.whenTrue, checkMode); + var type2 = checkExpression(node.whenFalse, checkMode); + return getUnionType([type1, type2], 2); + } + function checkTemplateExpression(node) { + ts.forEach(node.templateSpans, function (templateSpan) { + if (maybeTypeOfKind(checkExpression(templateSpan.expression), 12288)) { + error(templateSpan.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String); + } + }); + return stringType; + } + function getContextNode(node) { + if (node.kind === 274 && !ts.isJsxSelfClosingElement(node.parent)) { + return node.parent.parent; + } + return node; + } + function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) { + var context = getContextNode(node); + var saveContextualType = context.contextualType; + var saveInferenceContext = context.inferenceContext; + try { + context.contextualType = contextualType; + context.inferenceContext = inferenceContext; + var type = checkExpression(node, checkMode | 1 | (inferenceContext ? 2 : 0)); + var result = maybeTypeOfKind(type, 2944) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ? + getRegularTypeOfLiteralType(type) : type; + return result; + } + finally { + context.contextualType = saveContextualType; + context.inferenceContext = saveInferenceContext; + } + } + function checkExpressionCached(node, checkMode) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + if (checkMode && checkMode !== 0) { + return checkExpression(node, checkMode); + } + var saveFlowLoopStart = flowLoopStart; + var saveFlowTypeCache = flowTypeCache; + flowLoopStart = flowLoopCount; + flowTypeCache = undefined; + links.resolvedType = checkExpression(node, checkMode); + flowTypeCache = saveFlowTypeCache; + flowLoopStart = saveFlowLoopStart; + } + return links.resolvedType; + } + function isTypeAssertion(node) { + node = ts.skipParentheses(node); + return node.kind === 199 || node.kind === 217; + } + function checkDeclarationInitializer(declaration, contextualType) { + var initializer = ts.getEffectiveInitializer(declaration); + var type = getQuickTypeOfExpression(initializer) || + (contextualType ? checkExpressionWithContextualType(initializer, contextualType, undefined, 0) : checkExpressionCached(initializer)); + return ts.isParameter(declaration) && declaration.name.kind === 190 && + isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ? + padTupleType(type, declaration.name) : type; + } + function padTupleType(type, pattern) { + var patternElements = pattern.elements; + var arity = getTypeReferenceArity(type); + var elementTypes = arity ? getTypeArguments(type).slice() : []; + for (var i = arity; i < patternElements.length; i++) { + var e = patternElements[i]; + if (i < patternElements.length - 1 || !(e.kind === 191 && e.dotDotDotToken)) { + elementTypes.push(!ts.isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, false, false) : anyType); + if (!ts.isOmittedExpression(e) && !hasDefaultValue(e)) { + reportImplicitAny(e, anyType); + } + } + } + return createTupleType(elementTypes, type.target.minLength, false, type.target.readonly); + } + function widenTypeInferredFromInitializer(declaration, type) { + var widened = ts.getCombinedNodeFlags(declaration) & 2 || ts.isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type); + if (ts.isInJSFile(declaration)) { + if (widened.flags & 98304) { + reportImplicitAny(declaration, anyType); + return anyType; + } + else if (isEmptyArrayLiteralType(widened)) { + reportImplicitAny(declaration, anyArrayType); + return anyArrayType; + } + } + return widened; + } + function isLiteralOfContextualType(candidateType, contextualType) { + if (contextualType) { + if (contextualType.flags & 3145728) { + var types = contextualType.types; + return ts.some(types, function (t) { return isLiteralOfContextualType(candidateType, t); }); + } + if (contextualType.flags & 58982400) { + var constraint = getBaseConstraintOfType(contextualType) || unknownType; + return maybeTypeOfKind(constraint, 4) && maybeTypeOfKind(candidateType, 128) || + maybeTypeOfKind(constraint, 8) && maybeTypeOfKind(candidateType, 256) || + maybeTypeOfKind(constraint, 64) && maybeTypeOfKind(candidateType, 2048) || + maybeTypeOfKind(constraint, 4096) && maybeTypeOfKind(candidateType, 8192) || + isLiteralOfContextualType(candidateType, constraint); + } + return !!(contextualType.flags & (128 | 4194304) && maybeTypeOfKind(candidateType, 128) || + contextualType.flags & 256 && maybeTypeOfKind(candidateType, 256) || + contextualType.flags & 2048 && maybeTypeOfKind(candidateType, 2048) || + contextualType.flags & 512 && maybeTypeOfKind(candidateType, 512) || + contextualType.flags & 8192 && maybeTypeOfKind(candidateType, 8192)); + } + return false; + } + function isConstContext(node) { + var parent = node.parent; + return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) || + (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) || + (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent)) && isConstContext(parent.parent); + } + function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) { + var type = checkExpression(node, checkMode, forceTuple); + return isConstContext(node) ? getRegularTypeOfLiteralType(type) : + isTypeAssertion(node) ? type : + getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node)); + } + function checkPropertyAssignment(node, checkMode) { + if (node.name.kind === 154) { + checkComputedPropertyName(node.name); + } + return checkExpressionForMutableLocation(node.initializer, checkMode); + } + function checkObjectLiteralMethod(node, checkMode) { + checkGrammarMethod(node); + if (node.name.kind === 154) { + checkComputedPropertyName(node.name); + } + var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode); + return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode); + } + function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) { + if (checkMode && checkMode & (2 | 8)) { + var callSignature = getSingleSignature(type, 0, true); + var constructSignature = getSingleSignature(type, 1, true); + var signature = callSignature || constructSignature; + if (signature && signature.typeParameters) { + var contextualType = getApparentTypeOfContextualType(node, 2); + if (contextualType) { + var contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 : 1, false); + if (contextualSignature && !contextualSignature.typeParameters) { + if (checkMode & 8) { + skippedGenericFunction(node, checkMode); + return anyFunctionType; + } + var context = getInferenceContext(node); + var returnType = context.signature && getReturnTypeOfSignature(context.signature); + var returnSignature = returnType && getSingleCallOrConstructSignature(returnType); + if (returnSignature && !returnSignature.typeParameters && !ts.every(context.inferences, hasInferenceCandidates)) { + var uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters); + var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters); + var inferences_3 = ts.map(context.inferences, function (info) { return createInferenceInfo(info.typeParameter); }); + applyToParameterTypes(instantiatedSignature, contextualSignature, function (source, target) { + inferTypes(inferences_3, source, target, 0, true); + }); + if (ts.some(inferences_3, hasInferenceCandidates)) { + applyToReturnTypes(instantiatedSignature, contextualSignature, function (source, target) { + inferTypes(inferences_3, source, target); + }); + if (!hasOverlappingInferences(context.inferences, inferences_3)) { + mergeInferences(context.inferences, inferences_3); + context.inferredTypeParameters = ts.concatenate(context.inferredTypeParameters, uniqueTypeParameters); + return getOrCreateTypeFromSignature(instantiatedSignature); + } + } + } + return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context)); + } + } + } + } + return type; + } + function skippedGenericFunction(node, checkMode) { + if (checkMode & 2) { + var context = getInferenceContext(node); + context.flags |= 4; + } + } + function hasInferenceCandidates(info) { + return !!(info.candidates || info.contraCandidates); + } + function hasOverlappingInferences(a, b) { + for (var i = 0; i < a.length; i++) { + if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) { + return true; + } + } + return false; + } + function mergeInferences(target, source) { + for (var i = 0; i < target.length; i++) { + if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) { + target[i] = source[i]; + } + } + } + function getUniqueTypeParameters(context, typeParameters) { + var result = []; + var oldTypeParameters; + var newTypeParameters; + for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) { + var tp = typeParameters_2[_i]; + var name = tp.symbol.escapedName; + if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) { + var newName = getUniqueTypeParameterName(ts.concatenate(context.inferredTypeParameters, result), name); + var symbol = createSymbol(262144, newName); + var newTypeParameter = createTypeParameter(symbol); + newTypeParameter.target = tp; + oldTypeParameters = ts.append(oldTypeParameters, tp); + newTypeParameters = ts.append(newTypeParameters, newTypeParameter); + result.push(newTypeParameter); + } + else { + result.push(tp); + } + } + if (newTypeParameters) { + var mapper = createTypeMapper(oldTypeParameters, newTypeParameters); + for (var _a = 0, newTypeParameters_1 = newTypeParameters; _a < newTypeParameters_1.length; _a++) { + var tp = newTypeParameters_1[_a]; + tp.mapper = mapper; + } + } + return result; + } + function hasTypeParameterByName(typeParameters, name) { + return ts.some(typeParameters, function (tp) { return tp.symbol.escapedName === name; }); + } + function getUniqueTypeParameterName(typeParameters, baseName) { + var len = baseName.length; + while (len > 1 && baseName.charCodeAt(len - 1) >= 48 && baseName.charCodeAt(len - 1) <= 57) + len--; + var s = baseName.slice(0, len); + for (var index = 1; true; index++) { + var augmentedName = (s + index); + if (!hasTypeParameterByName(typeParameters, augmentedName)) { + return augmentedName; + } + } + } + function getReturnTypeOfSingleNonGenericCallSignature(funcType) { + var signature = getSingleCallSignature(funcType); + if (signature && !signature.typeParameters) { + return getReturnTypeOfSignature(signature); + } + } + function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) { + var funcType = checkExpression(expr.expression); + var nonOptionalType = getOptionalExpressionType(funcType, expr.expression); + var returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType); + return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType); + } + function getTypeOfExpression(node) { + var quickType = getQuickTypeOfExpression(node); + if (quickType) { + return quickType; + } + if (node.flags & 67108864 && flowTypeCache) { + var cachedType = flowTypeCache[getNodeId(node)]; + if (cachedType) { + return cachedType; + } + } + var startInvocationCount = flowInvocationCount; + var type = checkExpression(node); + if (flowInvocationCount !== startInvocationCount) { + var cache = flowTypeCache || (flowTypeCache = []); + cache[getNodeId(node)] = type; + node.flags |= 67108864; + } + return type; + } + function getQuickTypeOfExpression(node) { + var expr = ts.skipParentheses(node); + if (ts.isCallExpression(expr) && expr.expression.kind !== 102 && !ts.isRequireCall(expr, true) && !isSymbolOrSymbolForCall(expr)) { + var type = ts.isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : + getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression)); + if (type) { + return type; + } + } + else if (ts.isAssertionExpression(expr) && !ts.isConstTypeReference(expr.type)) { + return getTypeFromTypeNode(expr.type); + } + else if (node.kind === 8 || node.kind === 10 || + node.kind === 106 || node.kind === 91) { + return checkExpression(node); + } + return undefined; + } + function getContextFreeTypeOfExpression(node) { + var links = getNodeLinks(node); + if (links.contextFreeType) { + return links.contextFreeType; + } + var saveContextualType = node.contextualType; + node.contextualType = anyType; + try { + var type = links.contextFreeType = checkExpression(node, 4); + return type; + } + finally { + node.contextualType = saveContextualType; + } + } + function checkExpression(node, checkMode, forceTuple) { + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + var uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple); + var type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode); + if (isConstEnumObjectType(type)) { + checkConstEnumAccess(node, type); + } + currentNode = saveCurrentNode; + return type; + } + function checkConstEnumAccess(node, type) { + var ok = (node.parent.kind === 194 && node.parent.expression === node) || + (node.parent.kind === 195 && node.parent.expression === node) || + ((node.kind === 75 || node.kind === 153) && isInRightSideOfImportOrExportAssignment(node) || + (node.parent.kind === 172 && node.parent.exprName === node)) || + (node.parent.kind === 263); + if (!ok) { + error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); + } + if (compilerOptions.isolatedModules) { + ts.Debug.assert(!!(type.symbol.flags & 128)); + var constEnumDeclaration = type.symbol.valueDeclaration; + if (constEnumDeclaration.flags & 8388608) { + error(node, ts.Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided); + } + } + } + function checkParenthesizedExpression(node, checkMode) { + var tag = ts.isInJSFile(node) ? ts.getJSDocTypeTag(node) : undefined; + if (tag) { + return checkAssertionWorker(tag, tag.typeExpression.type, node.expression, checkMode); + } + return checkExpression(node.expression, checkMode); + } + function checkExpressionWorker(node, checkMode, forceTuple) { + var kind = node.kind; + if (cancellationToken) { + switch (kind) { + case 214: + case 201: + case 202: + cancellationToken.throwIfCancellationRequested(); + } + } + switch (kind) { + case 75: + return checkIdentifier(node); + case 104: + return checkThisExpression(node); + case 102: + return checkSuperExpression(node); + case 100: + return nullWideningType; + case 14: + case 10: + return getFreshTypeOfLiteralType(getLiteralType(node.text)); + case 8: + checkGrammarNumericLiteral(node); + return getFreshTypeOfLiteralType(getLiteralType(+node.text)); + case 9: + checkGrammarBigIntLiteral(node); + return getFreshTypeOfLiteralType(getBigIntLiteralType(node)); + case 106: + return trueType; + case 91: + return falseType; + case 211: + return checkTemplateExpression(node); + case 13: + return globalRegExpType; + case 192: + return checkArrayLiteral(node, checkMode, forceTuple); + case 193: + return checkObjectLiteral(node, checkMode); + case 194: + return checkPropertyAccessExpression(node); + case 153: + return checkQualifiedName(node); + case 195: + return checkIndexedAccess(node); + case 196: + if (node.expression.kind === 96) { + return checkImportCallExpression(node); + } + case 197: + return checkCallExpression(node, checkMode); + case 198: + return checkTaggedTemplateExpression(node); + case 200: + return checkParenthesizedExpression(node, checkMode); + case 214: + return checkClassExpression(node); + case 201: + case 202: + return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode); + case 204: + return checkTypeOfExpression(node); + case 199: + case 217: + return checkAssertion(node); + case 218: + return checkNonNullAssertion(node); + case 219: + return checkMetaProperty(node); + case 203: + return checkDeleteExpression(node); + case 205: + return checkVoidExpression(node); + case 206: + return checkAwaitExpression(node); + case 207: + return checkPrefixUnaryExpression(node); + case 208: + return checkPostfixUnaryExpression(node); + case 209: + return checkBinaryExpression(node, checkMode); + case 210: + return checkConditionalExpression(node, checkMode); + case 213: + return checkSpreadExpression(node, checkMode); + case 215: + return undefinedWideningType; + case 212: + return checkYieldExpression(node); + case 220: + return node.type; + case 276: + return checkJsxExpression(node, checkMode); + case 266: + return checkJsxElement(node, checkMode); + case 267: + return checkJsxSelfClosingElement(node, checkMode); + case 270: + return checkJsxFragment(node); + case 274: + return checkJsxAttributes(node, checkMode); + case 268: + ts.Debug.fail("Shouldn't ever directly check a JsxOpeningElement"); + } + return errorType; + } + function checkTypeParameter(node) { + if (node.expression) { + grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); + } + checkSourceElement(node.constraint); + checkSourceElement(node.default); + var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node)); + getBaseConstraintOfType(typeParameter); + if (!hasNonCircularTypeParameterDefault(typeParameter)) { + error(node.default, ts.Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter)); + } + var constraintType = getConstraintOfTypeParameter(typeParameter); + var defaultType = getDefaultFromTypeParameter(typeParameter); + if (constraintType && defaultType) { + checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + if (produceDiagnostics) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); + } + } + function checkParameter(node) { + checkGrammarDecoratorsAndModifiers(node); + checkVariableLikeDeclaration(node); + var func = ts.getContainingFunction(node); + if (ts.hasModifier(node, 92)) { + if (!(func.kind === 162 && ts.nodeIsPresent(func.body))) { + error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); + } + } + if (node.questionToken && ts.isBindingPattern(node.name) && func.body) { + error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); + } + if (node.name && ts.isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) { + if (func.parameters.indexOf(node) !== 0) { + error(node, ts.Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText); + } + if (func.kind === 162 || func.kind === 166 || func.kind === 171) { + error(node, ts.Diagnostics.A_constructor_cannot_have_a_this_parameter); + } + if (func.kind === 202) { + error(node, ts.Diagnostics.An_arrow_function_cannot_have_a_this_parameter); + } + } + if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isTypeAssignableTo(getTypeOfSymbol(node.symbol), anyReadonlyArrayType)) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type); + } + } + function checkTypePredicate(node) { + var parent = getTypePredicateParent(node); + if (!parent) { + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + return; + } + var signature = getSignatureFromDeclaration(parent); + var typePredicate = getTypePredicateOfSignature(signature); + if (!typePredicate) { + return; + } + checkSourceElement(node.type); + var parameterName = node.parameterName; + if (typePredicate.kind === 0 || typePredicate.kind === 2) { + getTypeFromThisTypeNode(parameterName); + } + else { + if (typePredicate.parameterIndex >= 0) { + if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) { + error(parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + if (typePredicate.type) { + var leadingError = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type); }; + checkTypeAssignableTo(typePredicate.type, getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]), node.type, undefined, leadingError); + } + } + } + else if (parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = parent.parameters; _i < _a.length; _i++) { + var name = _a[_i].name; + if (ts.isBindingPattern(name) && + checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) { + hasReportedError = true; + break; + } + } + if (!hasReportedError) { + error(node.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + } + function getTypePredicateParent(node) { + switch (node.parent.kind) { + case 202: + case 165: + case 244: + case 201: + case 170: + case 161: + case 160: + var parent = node.parent; + if (node === parent.type) { + return parent; + } + } + } + function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (ts.isOmittedExpression(element)) { + continue; + } + var name = element.name; + if (name.kind === 75 && name.escapedText === predicateVariableName) { + error(predicateVariableNode, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, predicateVariableName); + return true; + } + else if (name.kind === 190 || name.kind === 189) { + if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, predicateVariableNode, predicateVariableName)) { + return true; + } + } + } + } + function checkSignatureDeclaration(node) { + if (node.kind === 167) { + checkGrammarIndexSignature(node); + } + else if (node.kind === 170 || node.kind === 244 || node.kind === 171 || + node.kind === 165 || node.kind === 162 || + node.kind === 166) { + checkGrammarFunctionLikeDeclaration(node); + } + var functionFlags = ts.getFunctionFlags(node); + if (!(functionFlags & 4)) { + if ((functionFlags & 3) === 3 && languageVersion < 99) { + checkExternalEmitHelpers(node, 12288); + } + if ((functionFlags & 3) === 2 && languageVersion < 4) { + checkExternalEmitHelpers(node, 64); + } + if ((functionFlags & 3) !== 0 && languageVersion < 2) { + checkExternalEmitHelpers(node, 128); + } + } + checkTypeParameters(node.typeParameters); + ts.forEach(node.parameters, checkParameter); + if (node.type) { + checkSourceElement(node.type); + } + if (produceDiagnostics) { + checkCollisionWithArgumentsInGeneratedCode(node); + var returnTypeNode = ts.getEffectiveReturnTypeNode(node); + if (noImplicitAny && !returnTypeNode) { + switch (node.kind) { + case 166: + error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + case 165: + error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + } + } + if (returnTypeNode) { + var functionFlags_1 = ts.getFunctionFlags(node); + if ((functionFlags_1 & (4 | 1)) === 1) { + var returnType = getTypeFromTypeNode(returnTypeNode); + if (returnType === voidType) { + error(returnTypeNode, ts.Diagnostics.A_generator_cannot_have_a_void_type_annotation); + } + else { + var generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0, returnType, (functionFlags_1 & 2) !== 0) || anyType; + var generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, (functionFlags_1 & 2) !== 0) || generatorYieldType; + var generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2, returnType, (functionFlags_1 & 2) !== 0) || unknownType; + var generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags_1 & 2)); + checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode); + } + } + else if ((functionFlags_1 & 3) === 2) { + checkAsyncFunctionReturnType(node, returnTypeNode); + } + } + if (node.kind !== 167 && node.kind !== 300) { + registerForUnusedIdentifiersCheck(node); + } + } + } + function checkClassForDuplicateDeclarations(node) { + var instanceNames = ts.createUnderscoreEscapedMap(); + var staticNames = ts.createUnderscoreEscapedMap(); + var privateIdentifiers = ts.createUnderscoreEscapedMap(); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (member.kind === 162) { + for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) { + var param = _c[_b]; + if (ts.isParameterPropertyDeclaration(param, member) && !ts.isBindingPattern(param.name)) { + addName(instanceNames, param.name, param.name.escapedText, 3); + } + } + } + else { + var isStatic = ts.hasModifier(member, 32); + var name = member.name; + if (!name) { + return; + } + var names = ts.isPrivateIdentifier(name) ? privateIdentifiers : + isStatic ? staticNames : + instanceNames; + var memberName = name && ts.getPropertyNameForPropertyNameNode(name); + if (memberName) { + switch (member.kind) { + case 163: + addName(names, name, memberName, 1); + break; + case 164: + addName(names, name, memberName, 2); + break; + case 159: + addName(names, name, memberName, 3); + break; + case 161: + addName(names, name, memberName, 8); + break; + } + } + } + } + function addName(names, location, name, meaning) { + var prev = names.get(name); + if (prev) { + if (prev & 8) { + if (meaning !== 8) { + error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location)); + } + } + else if (prev & meaning) { + error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location)); + } + else { + names.set(name, prev | meaning); + } + } + else { + names.set(name, meaning); + } + } + } + function checkClassForStaticPropertyNameConflicts(node) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + var memberNameNode = member.name; + var isStatic = ts.hasModifier(member, 32); + if (isStatic && memberNameNode) { + var memberName = ts.getPropertyNameForPropertyNameNode(memberNameNode); + switch (memberName) { + case "name": + case "length": + case "caller": + case "arguments": + case "prototype": + var message = ts.Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1; + var className = getNameOfSymbolAsWritten(getSymbolOfNode(node)); + error(memberNameNode, message, memberName, className); + break; + } + } + } + } + function checkObjectTypeForDuplicateDeclarations(node) { + var names = ts.createMap(); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (member.kind === 158) { + var memberName = void 0; + var name = member.name; + switch (name.kind) { + case 10: + case 8: + memberName = name.text; + break; + case 75: + memberName = ts.idText(name); + break; + default: + continue; + } + if (names.get(memberName)) { + error(ts.getNameOfDeclaration(member.symbol.valueDeclaration), ts.Diagnostics.Duplicate_identifier_0, memberName); + error(member.name, ts.Diagnostics.Duplicate_identifier_0, memberName); + } + else { + names.set(memberName, true); + } + } + } + } + function checkTypeForDuplicateIndexSignatures(node) { + if (node.kind === 246) { + var nodeSymbol = getSymbolOfNode(node); + if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { + return; + } + } + var indexSymbol = getIndexSymbol(getSymbolOfNode(node)); + if (indexSymbol) { + var seenNumericIndexer = false; + var seenStringIndexer = false; + for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var declaration = decl; + if (declaration.parameters.length === 1 && declaration.parameters[0].type) { + switch (declaration.parameters[0].type.kind) { + case 143: + if (!seenStringIndexer) { + seenStringIndexer = true; + } + else { + error(declaration, ts.Diagnostics.Duplicate_string_index_signature); + } + break; + case 140: + if (!seenNumericIndexer) { + seenNumericIndexer = true; + } + else { + error(declaration, ts.Diagnostics.Duplicate_number_index_signature); + } + break; + } + } + } + } + } + function checkPropertyDeclaration(node) { + if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node)) + checkGrammarComputedPropertyName(node.name); + checkVariableLikeDeclaration(node); + if (ts.isPrivateIdentifier(node.name) && languageVersion < 99) { + for (var lexicalScope = ts.getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = ts.getEnclosingBlockScopeContainer(lexicalScope)) { + getNodeLinks(lexicalScope).flags |= 67108864; + } + } + } + function checkPropertySignature(node) { + if (ts.isPrivateIdentifier(node.name)) { + error(node, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + return checkPropertyDeclaration(node); + } + function checkMethodDeclaration(node) { + if (!checkGrammarMethod(node)) + checkGrammarComputedPropertyName(node.name); + if (ts.isPrivateIdentifier(node.name)) { + error(node, ts.Diagnostics.A_method_cannot_be_named_with_a_private_identifier); + } + checkFunctionOrMethodDeclaration(node); + if (ts.hasModifier(node, 128) && node.kind === 161 && node.body) { + error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name)); + } + } + function checkConstructorDeclaration(node) { + checkSignatureDeclaration(node); + if (!checkGrammarConstructorTypeParameters(node)) + checkGrammarConstructorTypeAnnotation(node); + checkSourceElement(node.body); + var symbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind); + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(symbol); + } + if (ts.nodeIsMissing(node.body)) { + return; + } + if (!produceDiagnostics) { + return; + } + function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) { + if (ts.isPrivateIdentifierPropertyDeclaration(n)) { + return true; + } + return n.kind === 159 && + !ts.hasModifier(n, 32) && + !!n.initializer; + } + var containingClassDecl = node.parent; + if (ts.getClassExtendsHeritageElement(containingClassDecl)) { + captureLexicalThis(node.parent, containingClassDecl); + var classExtendsNull = classDeclarationExtendsNull(containingClassDecl); + var superCall = getSuperCallInConstructor(node); + if (superCall) { + if (classExtendsNull) { + error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null); + } + var superCallShouldBeFirst = ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || + ts.some(node.parameters, function (p) { return ts.hasModifier(p, 92); }); + if (superCallShouldBeFirst) { + var statements = node.body.statements; + var superCallStatement = void 0; + for (var _i = 0, statements_3 = statements; _i < statements_3.length; _i++) { + var statement = statements_3[_i]; + if (statement.kind === 226 && ts.isSuperCall(statement.expression)) { + superCallStatement = statement; + break; + } + if (!ts.isPrologueDirective(statement)) { + break; + } + } + if (!superCallStatement) { + error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers); + } + } + } + else if (!classExtendsNull) { + error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call); + } + } + } + function checkAccessorDeclaration(node) { + if (produceDiagnostics) { + if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node)) + checkGrammarComputedPropertyName(node.name); + checkDecorators(node); + checkSignatureDeclaration(node); + if (node.kind === 163) { + if (!(node.flags & 8388608) && ts.nodeIsPresent(node.body) && (node.flags & 256)) { + if (!(node.flags & 512)) { + error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value); + } + } + } + if (node.name.kind === 154) { + checkComputedPropertyName(node.name); + } + if (ts.isPrivateIdentifier(node.name)) { + error(node.name, ts.Diagnostics.An_accessor_cannot_be_named_with_a_private_identifier); + } + if (!hasNonBindableDynamicName(node)) { + var otherKind = node.kind === 163 ? 164 : 163; + var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind); + if (otherAccessor) { + var nodeFlags = ts.getModifierFlags(node); + var otherFlags = ts.getModifierFlags(otherAccessor); + if ((nodeFlags & 28) !== (otherFlags & 28)) { + error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility); + } + if ((nodeFlags & 128) !== (otherFlags & 128)) { + error(node.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract); + } + checkAccessorDeclarationTypesIdentical(node, otherAccessor, getAnnotatedAccessorType, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type); + checkAccessorDeclarationTypesIdentical(node, otherAccessor, getThisTypeOfDeclaration, ts.Diagnostics.get_and_set_accessor_must_have_the_same_this_type); + } + } + var returnType = getTypeOfAccessors(getSymbolOfNode(node)); + if (node.kind === 163) { + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType); + } + } + checkSourceElement(node.body); + } + function checkAccessorDeclarationTypesIdentical(first, second, getAnnotatedType, message) { + var firstType = getAnnotatedType(first); + var secondType = getAnnotatedType(second); + if (firstType && secondType && !isTypeIdenticalTo(firstType, secondType)) { + error(first, message); + } + } + function checkMissingDeclaration(node) { + checkDecorators(node); + } + function getEffectiveTypeArguments(node, typeParameters) { + return fillMissingTypeArguments(ts.map(node.typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(node)); + } + function checkTypeArgumentConstraints(node, typeParameters) { + var typeArguments; + var mapper; + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + if (!typeArguments) { + typeArguments = getEffectiveTypeArguments(node, typeParameters); + mapper = createTypeMapper(typeParameters, typeArguments); + } + result = result && checkTypeAssignableTo(typeArguments[i], instantiateType(constraint, mapper), node.typeArguments[i], ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } + function getTypeParametersForTypeReference(node) { + var type = getTypeFromTypeReference(node); + if (type !== errorType) { + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol) { + return symbol.flags & 524288 && getSymbolLinks(symbol).typeParameters || + (ts.getObjectFlags(type) & 4 ? type.target.localTypeParameters : undefined); + } + } + return undefined; + } + function checkTypeReferenceNode(node) { + checkGrammarTypeArguments(node, node.typeArguments); + if (node.kind === 169 && node.typeName.jsdocDotPos !== undefined && !ts.isInJSFile(node) && !ts.isInJSDoc(node)) { + grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + ts.forEach(node.typeArguments, checkSourceElement); + var type = getTypeFromTypeReference(node); + if (type !== errorType) { + if (node.typeArguments && produceDiagnostics) { + var typeParameters = getTypeParametersForTypeReference(node); + if (typeParameters) { + checkTypeArgumentConstraints(node, typeParameters); + } + } + if (type.flags & 32 && getNodeLinks(node).resolvedSymbol.flags & 8) { + error(node, ts.Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type)); + } + } + } + function getTypeArgumentConstraint(node) { + var typeReferenceNode = ts.tryCast(node.parent, ts.isTypeReferenceType); + if (!typeReferenceNode) + return undefined; + var typeParameters = getTypeParametersForTypeReference(typeReferenceNode); + var constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]); + return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters))); + } + function checkTypeQuery(node) { + getTypeFromTypeQueryNode(node); + } + function checkTypeLiteral(node) { + ts.forEach(node.members, checkSourceElement); + if (produceDiagnostics) { + var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + checkIndexConstraints(type); + checkTypeForDuplicateIndexSignatures(node); + checkObjectTypeForDuplicateDeclarations(node); + } + } + function checkArrayType(node) { + checkSourceElement(node.elementType); + } + function checkTupleType(node) { + var elementTypes = node.elementTypes; + var seenOptionalElement = false; + for (var i = 0; i < elementTypes.length; i++) { + var e = elementTypes[i]; + if (e.kind === 177) { + if (i !== elementTypes.length - 1) { + grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_must_be_last_in_a_tuple_type); + break; + } + if (!isArrayType(getTypeFromTypeNode(e.type))) { + error(e, ts.Diagnostics.A_rest_element_type_must_be_an_array_type); + } + } + else if (e.kind === 176) { + seenOptionalElement = true; + } + else if (seenOptionalElement) { + grammarErrorOnNode(e, ts.Diagnostics.A_required_element_cannot_follow_an_optional_element); + break; + } + } + ts.forEach(node.elementTypes, checkSourceElement); + } + function checkUnionOrIntersectionType(node) { + ts.forEach(node.types, checkSourceElement); + } + function checkIndexedAccessIndexType(type, accessNode) { + if (!(type.flags & 8388608)) { + return type; + } + var objectType = type.objectType; + var indexType = type.indexType; + if (isTypeAssignableTo(indexType, getIndexType(objectType, false))) { + if (accessNode.kind === 195 && ts.isAssignmentTarget(accessNode) && + ts.getObjectFlags(objectType) & 32 && getMappedTypeModifiers(objectType) & 1) { + error(accessNode, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType)); + } + return type; + } + var apparentObjectType = getApparentType(objectType); + if (getIndexInfoOfType(apparentObjectType, 1) && isTypeAssignableToKind(indexType, 296)) { + return type; + } + if (isGenericObjectType(objectType)) { + var propertyName_1 = getPropertyNameFromIndex(indexType, accessNode); + if (propertyName_1) { + var propertySymbol = forEachType(apparentObjectType, function (t) { return getPropertyOfType(t, propertyName_1); }); + if (propertySymbol && ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24) { + error(accessNode, ts.Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, ts.unescapeLeadingUnderscores(propertyName_1)); + return errorType; + } + } + } + error(accessNode, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType)); + return errorType; + } + function checkIndexedAccessType(node) { + checkSourceElement(node.objectType); + checkSourceElement(node.indexType); + checkIndexedAccessIndexType(getTypeFromIndexedAccessTypeNode(node), node); + } + function checkMappedType(node) { + checkSourceElement(node.typeParameter); + checkSourceElement(node.type); + if (!node.type) { + reportImplicitAny(node, anyType); + } + var type = getTypeFromMappedTypeNode(node); + var constraintType = getConstraintTypeFromMappedType(type); + checkTypeAssignableTo(constraintType, keyofConstraintType, ts.getEffectiveConstraintOfTypeParameter(node.typeParameter)); + } + function checkThisType(node) { + getTypeFromThisTypeNode(node); + } + function checkTypeOperator(node) { + checkGrammarTypeOperatorNode(node); + checkSourceElement(node.type); + } + function checkConditionalType(node) { + ts.forEachChild(node, checkSourceElement); + } + function checkInferType(node) { + if (!ts.findAncestor(node, function (n) { return n.parent && n.parent.kind === 180 && n.parent.extendsType === n; })) { + grammarErrorOnNode(node, ts.Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type); + } + checkSourceElement(node.typeParameter); + registerForUnusedIdentifiersCheck(node); + } + function checkImportType(node) { + checkSourceElement(node.argument); + getTypeFromTypeNode(node); + } + function isPrivateWithinAmbient(node) { + return (ts.hasModifier(node, 8) || ts.isPrivateIdentifierPropertyDeclaration(node)) && !!(node.flags & 8388608); + } + function getEffectiveDeclarationFlags(n, flagsToCheck) { + var flags = ts.getCombinedModifierFlags(n); + if (n.parent.kind !== 246 && + n.parent.kind !== 245 && + n.parent.kind !== 214 && + n.flags & 8388608) { + if (!(flags & 2) && !(ts.isModuleBlock(n.parent) && ts.isModuleDeclaration(n.parent.parent) && ts.isGlobalScopeAugmentation(n.parent.parent))) { + flags |= 1; + } + flags |= 2; + } + return flags & flagsToCheck; + } + function checkFunctionOrConstructorSymbol(symbol) { + if (!produceDiagnostics) { + return; + } + function getCanonicalOverload(overloads, implementation) { + var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent; + return implementationSharesContainerWithFirstOverload ? implementation : overloads[0]; + } + function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) { + var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags; + if (someButNotAllOverloadFlags !== 0) { + var canonicalFlags_1 = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck); + ts.forEach(overloads, function (o) { + var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags_1; + if (deviation & 1) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported); + } + else if (deviation & 2) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient); + } + else if (deviation & (8 | 16)) { + error(ts.getNameOfDeclaration(o) || o, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); + } + else if (deviation & 128) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract); + } + }); + } + } + function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) { + if (someHaveQuestionToken !== allHaveQuestionToken) { + var canonicalHasQuestionToken_1 = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation)); + ts.forEach(overloads, function (o) { + var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken_1; + if (deviation) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required); + } + }); + } + } + var flagsToCheck = 1 | 2 | 8 | 16 | 128; + var someNodeFlags = 0; + var allNodeFlags = flagsToCheck; + var someHaveQuestionToken = false; + var allHaveQuestionToken = true; + var hasOverloads = false; + var bodyDeclaration; + var lastSeenNonAmbientDeclaration; + var previousDeclaration; + var declarations = symbol.declarations; + var isConstructor = (symbol.flags & 16384) !== 0; + function reportImplementationExpectedError(node) { + if (node.name && ts.nodeIsMissing(node.name)) { + return; + } + var seen = false; + var subsequentNode = ts.forEachChild(node.parent, function (c) { + if (seen) { + return c; + } + else { + seen = c === node; + } + }); + if (subsequentNode && subsequentNode.pos === node.end) { + if (subsequentNode.kind === node.kind) { + var errorNode_1 = subsequentNode.name || subsequentNode; + var subsequentName = subsequentNode.name; + if (node.name && subsequentName && (ts.isPrivateIdentifier(node.name) && ts.isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText || + ts.isComputedPropertyName(node.name) && ts.isComputedPropertyName(subsequentName) || + ts.isPropertyNameLiteral(node.name) && ts.isPropertyNameLiteral(subsequentName) && + ts.getEscapedTextOfIdentifierOrLiteral(node.name) === ts.getEscapedTextOfIdentifierOrLiteral(subsequentName))) { + var reportError = (node.kind === 161 || node.kind === 160) && + ts.hasModifier(node, 32) !== ts.hasModifier(subsequentNode, 32); + if (reportError) { + var diagnostic = ts.hasModifier(node, 32) ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; + error(errorNode_1, diagnostic); + } + return; + } + if (ts.nodeIsPresent(subsequentNode.body)) { + error(errorNode_1, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name)); + return; + } + } + } + var errorNode = node.name || node; + if (isConstructor) { + error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing); + } + else { + if (ts.hasModifier(node, 128)) { + error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive); + } + else { + error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + } + } + } + var duplicateFunctionDeclaration = false; + var multipleConstructorImplementation = false; + var hasNonAmbientClass = false; + for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) { + var current = declarations_4[_i]; + var node = current; + var inAmbientContext = node.flags & 8388608; + var inAmbientContextOrInterface = node.parent.kind === 246 || node.parent.kind === 173 || inAmbientContext; + if (inAmbientContextOrInterface) { + previousDeclaration = undefined; + } + if ((node.kind === 245 || node.kind === 214) && !inAmbientContext) { + hasNonAmbientClass = true; + } + if (node.kind === 244 || node.kind === 161 || node.kind === 160 || node.kind === 162) { + var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); + someNodeFlags |= currentNodeFlags; + allNodeFlags &= currentNodeFlags; + someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node); + allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node); + if (ts.nodeIsPresent(node.body) && bodyDeclaration) { + if (isConstructor) { + multipleConstructorImplementation = true; + } + else { + duplicateFunctionDeclaration = true; + } + } + else if (previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) { + reportImplementationExpectedError(previousDeclaration); + } + if (ts.nodeIsPresent(node.body)) { + if (!bodyDeclaration) { + bodyDeclaration = node; + } + } + else { + hasOverloads = true; + } + previousDeclaration = node; + if (!inAmbientContextOrInterface) { + lastSeenNonAmbientDeclaration = node; + } + } + } + if (multipleConstructorImplementation) { + ts.forEach(declarations, function (declaration) { + error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed); + }); + } + if (duplicateFunctionDeclaration) { + ts.forEach(declarations, function (declaration) { + error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Duplicate_function_implementation); + }); + } + if (hasNonAmbientClass && !isConstructor && symbol.flags & 16) { + ts.forEach(declarations, function (declaration) { + addDuplicateDeclarationError(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(symbol), ts.filter(declarations, function (d) { return d !== declaration; })); + }); + } + if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && + !ts.hasModifier(lastSeenNonAmbientDeclaration, 128) && !lastSeenNonAmbientDeclaration.questionToken) { + reportImplementationExpectedError(lastSeenNonAmbientDeclaration); + } + if (hasOverloads) { + checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags); + checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken); + if (bodyDeclaration) { + var signatures = getSignaturesOfSymbol(symbol); + var bodySignature = getSignatureFromDeclaration(bodyDeclaration); + for (var _a = 0, signatures_10 = signatures; _a < signatures_10.length; _a++) { + var signature = signatures_10[_a]; + if (!isImplementationCompatibleWithOverload(bodySignature, signature)) { + ts.addRelatedInfo(error(signature.declaration, ts.Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature), ts.createDiagnosticForNode(bodyDeclaration, ts.Diagnostics.The_implementation_signature_is_declared_here)); + break; + } + } + } + } + } + function checkExportsOnMergedDeclarations(node) { + if (!produceDiagnostics) { + return; + } + var symbol = node.localSymbol; + if (!symbol) { + symbol = getSymbolOfNode(node); + if (!symbol.exportSymbol) { + return; + } + } + if (ts.getDeclarationOfKind(symbol, node.kind) !== node) { + return; + } + var exportedDeclarationSpaces = 0; + var nonExportedDeclarationSpaces = 0; + var defaultExportedDeclarationSpaces = 0; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var d = _a[_i]; + var declarationSpaces = getDeclarationSpaces(d); + var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 | 512); + if (effectiveDeclarationFlags & 1) { + if (effectiveDeclarationFlags & 512) { + defaultExportedDeclarationSpaces |= declarationSpaces; + } + else { + exportedDeclarationSpaces |= declarationSpaces; + } + } + else { + nonExportedDeclarationSpaces |= declarationSpaces; + } + } + var nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces; + var commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces; + var commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces; + if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) { + for (var _b = 0, _c = symbol.declarations; _b < _c.length; _b++) { + var d = _c[_b]; + var declarationSpaces = getDeclarationSpaces(d); + var name = ts.getNameOfDeclaration(d); + if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) { + error(name, ts.Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, ts.declarationNameToString(name)); + } + else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) { + error(name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(name)); + } + } + } + function getDeclarationSpaces(decl) { + var d = decl; + switch (d.kind) { + case 246: + case 247: + case 321: + case 314: + case 315: + return 2; + case 249: + return ts.isAmbientModule(d) || ts.getModuleInstanceState(d) !== 0 + ? 4 | 1 + : 4; + case 245: + case 248: + case 284: + return 2 | 1; + case 290: + return 2 | 1 | 4; + case 259: + if (!ts.isEntityNameExpression(d.expression)) { + return 1; + } + d = d.expression; + case 253: + case 256: + case 255: + var result_7 = 0; + var target = resolveAlias(getSymbolOfNode(d)); + ts.forEach(target.declarations, function (d) { result_7 |= getDeclarationSpaces(d); }); + return result_7; + case 242: + case 191: + case 244: + case 258: + case 75: + return 1; + default: + return ts.Debug.failBadSyntaxKind(d); + } + } + } + function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) { + var promisedType = getPromisedTypeOfPromise(type, errorNode); + return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0); + } + function getPromisedTypeOfPromise(promise, errorNode) { + if (isTypeAny(promise)) { + return undefined; + } + var typeAsPromise = promise; + if (typeAsPromise.promisedTypeOfPromise) { + return typeAsPromise.promisedTypeOfPromise; + } + if (isReferenceToType(promise, getGlobalPromiseType(false))) { + return typeAsPromise.promisedTypeOfPromise = getTypeArguments(promise)[0]; + } + var thenFunction = getTypeOfPropertyOfType(promise, "then"); + if (isTypeAny(thenFunction)) { + return undefined; + } + var thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0) : ts.emptyArray; + if (thenSignatures.length === 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.A_promise_must_have_a_then_method); + } + return undefined; + } + var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(thenSignatures, getTypeOfFirstParameterOfSignature)), 2097152); + if (isTypeAny(onfulfilledParameterType)) { + return undefined; + } + var onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0); + if (onfulfilledParameterSignatures.length === 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback); + } + return undefined; + } + return typeAsPromise.promisedTypeOfPromise = getUnionType(ts.map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2); + } + function checkAwaitedType(type, errorNode, diagnosticMessage, arg0) { + var awaitedType = getAwaitedType(type, errorNode, diagnosticMessage, arg0); + return awaitedType || errorType; + } + function getAwaitedType(type, errorNode, diagnosticMessage, arg0) { + var typeAsAwaitable = type; + if (typeAsAwaitable.awaitedTypeOfType) { + return typeAsAwaitable.awaitedTypeOfType; + } + if (isTypeAny(type)) { + return typeAsAwaitable.awaitedTypeOfType = type; + } + if (type.flags & 1048576) { + var types = void 0; + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var constituentType = _a[_i]; + types = ts.append(types, getAwaitedType(constituentType, errorNode, diagnosticMessage, arg0)); + } + if (!types) { + return undefined; + } + return typeAsAwaitable.awaitedTypeOfType = getUnionType(types); + } + var promisedType = getPromisedTypeOfPromise(type); + if (promisedType) { + if (type.id === promisedType.id || awaitedTypeStack.indexOf(promisedType.id) >= 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); + } + return undefined; + } + awaitedTypeStack.push(type.id); + var awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0); + awaitedTypeStack.pop(); + if (!awaitedType) { + return undefined; + } + return typeAsAwaitable.awaitedTypeOfType = awaitedType; + } + var thenFunction = getTypeOfPropertyOfType(type, "then"); + if (thenFunction && getSignaturesOfType(thenFunction, 0).length > 0) { + if (errorNode) { + if (!diagnosticMessage) + return ts.Debug.fail(); + error(errorNode, diagnosticMessage, arg0); + } + return undefined; + } + return typeAsAwaitable.awaitedTypeOfType = type; + } + function checkAsyncFunctionReturnType(node, returnTypeNode) { + var returnType = getTypeFromTypeNode(returnTypeNode); + if (languageVersion >= 2) { + if (returnType === errorType) { + return; + } + var globalPromiseType = getGlobalPromiseType(true); + if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) { + error(returnTypeNode, ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type); + return; + } + } + else { + markTypeNodeAsReferenced(returnTypeNode); + if (returnType === errorType) { + return; + } + var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode); + if (promiseConstructorName === undefined) { + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, typeToString(returnType)); + return; + } + var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551, true); + var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType; + if (promiseConstructorType === errorType) { + if (promiseConstructorName.kind === 75 && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) { + error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); + } + else { + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName)); + } + return; + } + var globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(true); + if (globalPromiseConstructorLikeType === emptyObjectType) { + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName)); + return; + } + if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value)) { + return; + } + var rootName = promiseConstructorName && ts.getFirstIdentifier(promiseConstructorName); + var collidingSymbol = getSymbol(node.locals, rootName.escapedText, 111551); + if (collidingSymbol) { + error(collidingSymbol.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, ts.idText(rootName), ts.entityNameToString(promiseConstructorName)); + return; + } + } + checkAwaitedType(returnType, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + function checkDecorator(node) { + var signature = getResolvedSignature(node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1) { + return; + } + var expectedReturnType; + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + var errorInfo; + switch (node.parent.kind) { + case 245: + var classSymbol = getSymbolOfNode(node.parent); + var classConstructorType = getTypeOfSymbol(classSymbol); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 156: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); + break; + case 159: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); + break; + case 161: + case 163: + case 164: + var methodType = getTypeOfNode(node.parent); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); + break; + default: + return ts.Debug.fail(); + } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, function () { return errorInfo; }); + } + function markTypeNodeAsReferenced(node) { + markEntityNameOrEntityExpressionAsReference(node && ts.getEntityNameFromTypeNode(node)); + } + function markEntityNameOrEntityExpressionAsReference(typeName) { + if (!typeName) + return; + var rootName = ts.getFirstIdentifier(typeName); + var meaning = (typeName.kind === 75 ? 788968 : 1920) | 2097152; + var rootSymbol = resolveName(rootName, rootName.escapedText, meaning, undefined, undefined, true); + if (rootSymbol + && rootSymbol.flags & 2097152 + && symbolIsValue(rootSymbol) + && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) + && !getTypeOnlyAliasDeclaration(rootSymbol)) { + markAliasSymbolAsReferenced(rootSymbol); + } + } + function markDecoratorMedataDataTypeNodeAsReferenced(node) { + var entityName = getEntityNameForDecoratorMetadata(node); + if (entityName && ts.isEntityName(entityName)) { + markEntityNameOrEntityExpressionAsReference(entityName); + } + } + function getEntityNameForDecoratorMetadata(node) { + if (node) { + switch (node.kind) { + case 179: + case 178: + return getEntityNameForDecoratorMetadataFromTypeList(node.types); + case 180: + return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]); + case 182: + return getEntityNameForDecoratorMetadata(node.type); + case 169: + return node.typeName; + } + } + } + function getEntityNameForDecoratorMetadataFromTypeList(types) { + var commonEntityName; + for (var _i = 0, types_19 = types; _i < types_19.length; _i++) { + var typeNode = types_19[_i]; + while (typeNode.kind === 182) { + typeNode = typeNode.type; + } + if (typeNode.kind === 137) { + continue; + } + if (!strictNullChecks && (typeNode.kind === 100 || typeNode.kind === 146)) { + continue; + } + var individualEntityName = getEntityNameForDecoratorMetadata(typeNode); + if (!individualEntityName) { + return undefined; + } + if (commonEntityName) { + if (!ts.isIdentifier(commonEntityName) || + !ts.isIdentifier(individualEntityName) || + commonEntityName.escapedText !== individualEntityName.escapedText) { + return undefined; + } + } + else { + commonEntityName = individualEntityName; + } + } + return commonEntityName; + } + function getParameterTypeNodeForDecoratorCheck(node) { + var typeNode = ts.getEffectiveTypeAnnotationNode(node); + return ts.isRestParameter(node) ? ts.getRestParameterElementType(typeNode) : typeNode; + } + function checkDecorators(node) { + if (!node.decorators) { + return; + } + if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) { + return; + } + if (!compilerOptions.experimentalDecorators) { + error(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning); + } + var firstDecorator = node.decorators[0]; + checkExternalEmitHelpers(firstDecorator, 8); + if (node.kind === 156) { + checkExternalEmitHelpers(firstDecorator, 32); + } + if (compilerOptions.emitDecoratorMetadata) { + checkExternalEmitHelpers(firstDecorator, 16); + switch (node.kind) { + case 245: + var constructor = ts.getFirstConstructorWithBody(node); + if (constructor) { + for (var _i = 0, _a = constructor.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + } + break; + case 163: + case 164: + var otherKind = node.kind === 163 ? 164 : 163; + var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind); + markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor)); + break; + case 161: + for (var _b = 0, _c = node.parameters; _b < _c.length; _b++) { + var parameter = _c[_b]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveReturnTypeNode(node)); + break; + case 159: + markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveTypeAnnotationNode(node)); + break; + case 156: + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node)); + var containingSignature = node.parent; + for (var _d = 0, _e = containingSignature.parameters; _d < _e.length; _d++) { + var parameter = _e[_d]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + break; + } + } + ts.forEach(node.decorators, checkDecorator); + } + function checkFunctionDeclaration(node) { + if (produceDiagnostics) { + checkFunctionOrMethodDeclaration(node); + checkGrammarForGenerator(node); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + } + } + function checkJSDocTypeAliasTag(node) { + if (!node.typeExpression) { + error(node.name, ts.Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags); + } + if (node.name) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); + } + checkSourceElement(node.typeExpression); + } + function checkJSDocTemplateTag(node) { + checkSourceElement(node.constraint); + for (var _i = 0, _a = node.typeParameters; _i < _a.length; _i++) { + var tp = _a[_i]; + checkSourceElement(tp); + } + } + function checkJSDocTypeTag(node) { + checkSourceElement(node.typeExpression); + } + function checkJSDocParameterTag(node) { + checkSourceElement(node.typeExpression); + if (!ts.getParameterSymbolFromJSDoc(node)) { + var decl = ts.getHostSignatureFromJSDoc(node); + if (decl) { + var i = ts.getJSDocTags(decl).filter(ts.isJSDocParameterTag).indexOf(node); + if (i > -1 && i < decl.parameters.length && ts.isBindingPattern(decl.parameters[i].name)) { + return; + } + if (!containsArgumentsReference(decl)) { + if (ts.isQualifiedName(node.name)) { + error(node.name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(node.name), ts.entityNameToString(node.name.left)); + } + else { + error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(node.name)); + } + } + else if (ts.findLast(ts.getJSDocTags(decl), ts.isJSDocParameterTag) === node && + node.typeExpression && node.typeExpression.type && + !isArrayType(getTypeFromTypeNode(node.typeExpression.type))) { + error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(node.name.kind === 153 ? node.name.right : node.name)); + } + } + } + } + function checkJSDocFunctionType(node) { + if (produceDiagnostics && !node.type && !ts.isJSDocConstructSignature(node)) { + reportImplicitAny(node, anyType); + } + checkSignatureDeclaration(node); + } + function checkJSDocAugmentsTag(node) { + var classLike = ts.getJSDocHost(node); + if (!ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) { + error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName)); + return; + } + var augmentsTags = ts.getJSDocTags(classLike).filter(ts.isJSDocAugmentsTag); + ts.Debug.assert(augmentsTags.length > 0); + if (augmentsTags.length > 1) { + error(augmentsTags[1], ts.Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag); + } + var name = getIdentifierFromEntityNameExpression(node.class.expression); + var extend = ts.getClassExtendsHeritageElement(classLike); + if (extend) { + var className = getIdentifierFromEntityNameExpression(extend.expression); + if (className && name.escapedText !== className.escapedText) { + error(name, ts.Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, ts.idText(node.tagName), ts.idText(name), ts.idText(className)); + } + } + } + function getIdentifierFromEntityNameExpression(node) { + switch (node.kind) { + case 75: + return node; + case 194: + return node.name; + default: + return undefined; + } + } + function checkFunctionOrMethodDeclaration(node) { + checkDecorators(node); + checkSignatureDeclaration(node); + var functionFlags = ts.getFunctionFlags(node); + if (node.name && node.name.kind === 154) { + checkComputedPropertyName(node.name); + } + if (!hasNonBindableDynamicName(node)) { + var symbol = getSymbolOfNode(node); + var localSymbol = node.localSymbol || symbol; + var firstDeclaration = ts.find(localSymbol.declarations, function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 131072); }); + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(localSymbol); + } + if (symbol.parent) { + if (ts.getDeclarationOfKind(symbol, node.kind) === node) { + checkFunctionOrConstructorSymbol(symbol); + } + } + } + var body = node.kind === 160 ? undefined : node.body; + checkSourceElement(body); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node)); + if (produceDiagnostics && !ts.getEffectiveReturnTypeNode(node)) { + if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) { + reportImplicitAny(node, anyType); + } + if (functionFlags & 1 && ts.nodeIsPresent(body)) { + getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } + } + if (ts.isInJSFile(node)) { + var typeTag = ts.getJSDocTypeTag(node); + if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) { + error(typeTag, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature); + } + } + } + function registerForUnusedIdentifiersCheck(node) { + if (produceDiagnostics) { + var sourceFile = ts.getSourceFileOfNode(node); + var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path); + if (!potentiallyUnusedIdentifiers) { + potentiallyUnusedIdentifiers = []; + allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers); + } + potentiallyUnusedIdentifiers.push(node); + } + } + function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) { + for (var _i = 0, potentiallyUnusedIdentifiers_1 = potentiallyUnusedIdentifiers; _i < potentiallyUnusedIdentifiers_1.length; _i++) { + var node = potentiallyUnusedIdentifiers_1[_i]; + switch (node.kind) { + case 245: + case 214: + checkUnusedClassMembers(node, addDiagnostic); + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 290: + case 249: + case 223: + case 251: + case 230: + case 231: + case 232: + checkUnusedLocalsAndParameters(node, addDiagnostic); + break; + case 162: + case 201: + case 244: + case 202: + case 161: + case 163: + case 164: + if (node.body) { + checkUnusedLocalsAndParameters(node, addDiagnostic); + } + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 160: + case 165: + case 166: + case 170: + case 171: + case 247: + case 246: + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 181: + checkUnusedInferTypeParameter(node, addDiagnostic); + break; + default: + ts.Debug.assertNever(node, "Node should not have been registered for unused identifiers check"); + } + } + } + function errorUnusedLocal(declaration, name, addDiagnostic) { + var node = ts.getNameOfDeclaration(declaration) || declaration; + var message = isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read; + addDiagnostic(declaration, 0, ts.createDiagnosticForNode(node, message, name)); + } + function isIdentifierThatStartsWithUnderscore(node) { + return ts.isIdentifier(node) && ts.idText(node).charCodeAt(0) === 95; + } + function checkUnusedClassMembers(node, addDiagnostic) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + switch (member.kind) { + case 161: + case 159: + case 163: + case 164: + if (member.kind === 164 && member.symbol.flags & 32768) { + break; + } + var symbol = getSymbolOfNode(member); + if (!symbol.isReferenced && (ts.hasModifier(member, 8) || ts.isNamedDeclaration(member) && ts.isPrivateIdentifier(member.name))) { + addDiagnostic(member, 0, ts.createDiagnosticForNode(member.name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol))); + } + break; + case 162: + for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) { + var parameter = _c[_b]; + if (!parameter.symbol.isReferenced && ts.hasModifier(parameter, 8)) { + addDiagnostic(parameter, 0, ts.createDiagnosticForNode(parameter.name, ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read, ts.symbolName(parameter.symbol))); + } + } + break; + case 167: + case 222: + break; + default: + ts.Debug.fail(); + } + } + } + function checkUnusedInferTypeParameter(node, addDiagnostic) { + var typeParameter = node.typeParameter; + if (isTypeParameterUnused(typeParameter)) { + addDiagnostic(node, 1, ts.createDiagnosticForNode(node, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(typeParameter.name))); + } + } + function checkUnusedTypeParameters(node, addDiagnostic) { + if (ts.last(getSymbolOfNode(node).declarations) !== node) + return; + var typeParameters = ts.getEffectiveTypeParameterDeclarations(node); + var seenParentsWithEveryUnused = new ts.NodeSet(); + for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) { + var typeParameter = typeParameters_3[_i]; + if (!isTypeParameterUnused(typeParameter)) + continue; + var name = ts.idText(typeParameter.name); + var parent = typeParameter.parent; + if (parent.kind !== 181 && parent.typeParameters.every(isTypeParameterUnused)) { + if (seenParentsWithEveryUnused.tryAdd(parent)) { + var range = ts.isJSDocTemplateTag(parent) + ? ts.rangeOfNode(parent) + : ts.rangeOfTypeParameters(parent.typeParameters); + var only = typeParameters.length === 1; + var message = only ? ts.Diagnostics._0_is_declared_but_its_value_is_never_read : ts.Diagnostics.All_type_parameters_are_unused; + var arg0 = only ? name : undefined; + addDiagnostic(typeParameter, 1, ts.createFileDiagnostic(ts.getSourceFileOfNode(parent), range.pos, range.end - range.pos, message, arg0)); + } + } + else { + addDiagnostic(typeParameter, 1, ts.createDiagnosticForNode(typeParameter, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, name)); + } + } + } + function isTypeParameterUnused(typeParameter) { + return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144) && !isIdentifierThatStartsWithUnderscore(typeParameter.name); + } + function addToGroup(map, key, value, getKey) { + var keyString = String(getKey(key)); + var group = map.get(keyString); + if (group) { + group[1].push(value); + } + else { + map.set(keyString, [key, [value]]); + } + } + function tryGetRootParameterDeclaration(node) { + return ts.tryCast(ts.getRootDeclaration(node), ts.isParameter); + } + function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) { + var unusedImports = ts.createMap(); + var unusedDestructures = ts.createMap(); + var unusedVariables = ts.createMap(); + nodeWithLocals.locals.forEach(function (local) { + if (local.flags & 262144 ? !(local.flags & 3 && !(local.isReferenced & 3)) : local.isReferenced || local.exportSymbol) { + return; + } + for (var _i = 0, _a = local.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (ts.isAmbientModule(declaration) || + (ts.isVariableDeclaration(declaration) && ts.isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name)) { + continue; + } + if (isImportedDeclaration(declaration)) { + addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId); + } + else if (ts.isBindingElement(declaration) && ts.isObjectBindingPattern(declaration.parent)) { + var lastElement = ts.last(declaration.parent.elements); + if (declaration === lastElement || !ts.last(declaration.parent.elements).dotDotDotToken) { + addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId); + } + } + else if (ts.isVariableDeclaration(declaration)) { + addToGroup(unusedVariables, declaration.parent, declaration, getNodeId); + } + else { + var parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration); + var name = local.valueDeclaration && ts.getNameOfDeclaration(local.valueDeclaration); + if (parameter && name) { + if (!ts.isParameterPropertyDeclaration(parameter, parameter.parent) && !ts.parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) { + addDiagnostic(parameter, 1, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local))); + } + } + else { + errorUnusedLocal(declaration, ts.symbolName(local), addDiagnostic); + } + } + } + }); + unusedImports.forEach(function (_a) { + var importClause = _a[0], unuseds = _a[1]; + var importDecl = importClause.parent; + var nDeclarations = (importClause.name ? 1 : 0) + + (importClause.namedBindings ? + (importClause.namedBindings.kind === 256 ? 1 : importClause.namedBindings.elements.length) + : 0); + if (nDeclarations === unuseds.length) { + addDiagnostic(importDecl, 0, unuseds.length === 1 + ? ts.createDiagnosticForNode(importDecl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(ts.first(unuseds).name)) + : ts.createDiagnosticForNode(importDecl, ts.Diagnostics.All_imports_in_import_declaration_are_unused)); + } + else { + for (var _i = 0, unuseds_1 = unuseds; _i < unuseds_1.length; _i++) { + var unused = unuseds_1[_i]; + errorUnusedLocal(unused, ts.idText(unused.name), addDiagnostic); + } + } + }); + unusedDestructures.forEach(function (_a) { + var bindingPattern = _a[0], bindingElements = _a[1]; + var kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 : 0; + if (bindingPattern.elements.length === bindingElements.length) { + if (bindingElements.length === 1 && bindingPattern.parent.kind === 242 && bindingPattern.parent.parent.kind === 243) { + addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId); + } + else { + addDiagnostic(bindingPattern, kind, bindingElements.length === 1 + ? ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(bindingElements).name)) + : ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics.All_destructured_elements_are_unused)); + } + } + else { + for (var _i = 0, bindingElements_1 = bindingElements; _i < bindingElements_1.length; _i++) { + var e = bindingElements_1[_i]; + addDiagnostic(e, kind, ts.createDiagnosticForNode(e, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name))); + } + } + }); + unusedVariables.forEach(function (_a) { + var declarationList = _a[0], declarations = _a[1]; + if (declarationList.declarations.length === declarations.length) { + addDiagnostic(declarationList, 0, declarations.length === 1 + ? ts.createDiagnosticForNode(ts.first(declarations).name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(declarations).name)) + : ts.createDiagnosticForNode(declarationList.parent.kind === 225 ? declarationList.parent : declarationList, ts.Diagnostics.All_variables_are_unused)); + } + else { + for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) { + var decl = declarations_5[_i]; + addDiagnostic(decl, 0, ts.createDiagnosticForNode(decl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name))); + } + } + }); + } + function bindingNameText(name) { + switch (name.kind) { + case 75: + return ts.idText(name); + case 190: + case 189: + return bindingNameText(ts.cast(ts.first(name.elements), ts.isBindingElement).name); + default: + return ts.Debug.assertNever(name); + } + } + function isImportedDeclaration(node) { + return node.kind === 255 || node.kind === 258 || node.kind === 256; + } + function importClauseFromImported(decl) { + return decl.kind === 255 ? decl : decl.kind === 256 ? decl.parent : decl.parent.parent; + } + function checkBlock(node) { + if (node.kind === 223) { + checkGrammarStatementInAmbientContext(node); + } + if (ts.isFunctionOrModuleBlock(node)) { + var saveFlowAnalysisDisabled = flowAnalysisDisabled; + ts.forEach(node.statements, checkSourceElement); + flowAnalysisDisabled = saveFlowAnalysisDisabled; + } + else { + ts.forEach(node.statements, checkSourceElement); + } + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkCollisionWithArgumentsInGeneratedCode(node) { + if (languageVersion >= 2 || compilerOptions.noEmit || !ts.hasRestParameter(node) || node.flags & 8388608 || ts.nodeIsMissing(node.body)) { + return; + } + ts.forEach(node.parameters, function (p) { + if (p.name && !ts.isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) { + error(p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters); + } + }); + } + function needCollisionCheckForIdentifier(node, identifier, name) { + if (!(identifier && identifier.escapedText === name)) { + return false; + } + if (node.kind === 159 || + node.kind === 158 || + node.kind === 161 || + node.kind === 160 || + node.kind === 163 || + node.kind === 164) { + return false; + } + if (node.flags & 8388608) { + return false; + } + var root = ts.getRootDeclaration(node); + if (root.kind === 156 && ts.nodeIsMissing(root.parent.body)) { + return false; + } + return true; + } + function checkIfThisIsCapturedInEnclosingScope(node) { + ts.findAncestor(node, function (current) { + if (getNodeCheckFlags(current) & 4) { + var isDeclaration_1 = node.kind !== 75; + if (isDeclaration_1) { + error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference); + } + return true; + } + return false; + }); + } + function checkIfNewTargetIsCapturedInEnclosingScope(node) { + ts.findAncestor(node, function (current) { + if (getNodeCheckFlags(current) & 8) { + var isDeclaration_2 = node.kind !== 75; + if (isDeclaration_2) { + error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference); + } + return true; + } + return false; + }); + } + function checkWeakMapCollision(node) { + var enclosingBlockScope = ts.getEnclosingBlockScopeContainer(node); + if (getNodeCheckFlags(enclosingBlockScope) & 67108864) { + error(node, ts.Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap"); + } + } + function checkCollisionWithRequireExportsInGeneratedCode(node, name) { + if (moduleKind >= ts.ModuleKind.ES2015 || compilerOptions.noEmit) { + return; + } + if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { + return; + } + if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) { + return; + } + var parent = getDeclarationContainer(node); + if (parent.kind === 290 && ts.isExternalOrCommonJsModule(parent)) { + error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); + } + } + function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) { + if (languageVersion >= 4 || compilerOptions.noEmit || !needCollisionCheckForIdentifier(node, name, "Promise")) { + return; + } + if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) { + return; + } + var parent = getDeclarationContainer(node); + if (parent.kind === 290 && ts.isExternalOrCommonJsModule(parent) && parent.flags & 2048) { + error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, ts.declarationNameToString(name), ts.declarationNameToString(name)); + } + } + function checkVarDeclaredNamesNotShadowed(node) { + if ((ts.getCombinedNodeFlags(node) & 3) !== 0 || ts.isParameterDeclaration(node)) { + return; + } + if (node.kind === 242 && !node.initializer) { + return; + } + var symbol = getSymbolOfNode(node); + if (symbol.flags & 1) { + if (!ts.isIdentifier(node.name)) + return ts.Debug.fail(); + var localDeclarationSymbol = resolveName(node, node.name.escapedText, 3, undefined, undefined, false); + if (localDeclarationSymbol && + localDeclarationSymbol !== symbol && + localDeclarationSymbol.flags & 2) { + if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3) { + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 243); + var container = varDeclList.parent.kind === 225 && varDeclList.parent.parent + ? varDeclList.parent.parent + : undefined; + var namesShareScope = container && + (container.kind === 223 && ts.isFunctionLike(container.parent) || + container.kind === 250 || + container.kind === 249 || + container.kind === 290); + if (!namesShareScope) { + var name = symbolToString(localDeclarationSymbol); + error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); + } + } + } + } + } + function convertAutoToAny(type) { + return type === autoType ? anyType : type === autoArrayType ? anyArrayType : type; + } + function checkVariableLikeDeclaration(node) { + checkDecorators(node); + if (!ts.isBindingElement(node)) { + checkSourceElement(node.type); + } + if (!node.name) { + return; + } + if (node.name.kind === 154) { + checkComputedPropertyName(node.name); + if (node.initializer) { + checkExpressionCached(node.initializer); + } + } + if (node.kind === 191) { + if (node.parent.kind === 189 && languageVersion < 99) { + checkExternalEmitHelpers(node, 4); + } + if (node.propertyName && node.propertyName.kind === 154) { + checkComputedPropertyName(node.propertyName); + } + var parent = node.parent.parent; + var parentType = getTypeForBindingElementParent(parent); + var name = node.propertyName || node.name; + if (parentType && !ts.isBindingPattern(name)) { + var exprType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(exprType)) { + var nameText = getPropertyNameFromType(exprType); + var property = getPropertyOfType(parentType, nameText); + if (property) { + markPropertyAsReferenced(property, undefined, false); + checkPropertyAccessibility(parent, !!parent.initializer && parent.initializer.kind === 102, parentType, property); + } + } + } + } + if (ts.isBindingPattern(node.name)) { + if (node.name.kind === 190 && languageVersion < 2 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 512); + } + ts.forEach(node.name.elements, checkSourceElement); + } + if (node.initializer && ts.getRootDeclaration(node).kind === 156 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); + return; + } + if (ts.isBindingPattern(node.name)) { + var needCheckInitializer = node.initializer && node.parent.parent.kind !== 231; + var needCheckWidenedType = node.name.elements.length === 0; + if (needCheckInitializer || needCheckWidenedType) { + var widenedType = getWidenedTypeForVariableLikeDeclaration(node); + if (needCheckInitializer) { + var initializerType = checkExpressionCached(node.initializer); + if (strictNullChecks && needCheckWidenedType) { + checkNonNullNonVoidType(initializerType, node); + } + else { + checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer); + } + } + if (needCheckWidenedType) { + if (ts.isArrayBindingPattern(node.name)) { + checkIteratedTypeOrElementType(65, widenedType, undefinedType, node); + } + else if (strictNullChecks) { + checkNonNullNonVoidType(widenedType, node); + } + } + } + return; + } + var symbol = getSymbolOfNode(node); + var type = convertAutoToAny(getTypeOfSymbol(symbol)); + if (node === symbol.valueDeclaration) { + var initializer = ts.getEffectiveInitializer(node); + if (initializer) { + var isJSObjectLiteralInitializer = ts.isInJSFile(node) && + ts.isObjectLiteralExpression(initializer) && + (initializer.properties.length === 0 || ts.isPrototypeAccess(node.name)) && + ts.hasEntries(symbol.exports); + if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 231) { + checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, undefined); + } + } + if (symbol.declarations.length > 1) { + if (ts.some(symbol.declarations, function (d) { return d !== node && ts.isVariableLike(d) && !areDeclarationFlagsIdentical(d, node); })) { + error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name)); + } + } + } + else { + var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node)); + if (type !== errorType && declarationType !== errorType && + !isTypeIdenticalTo(type, declarationType) && + !(symbol.flags & 67108864)) { + errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType); + } + if (node.initializer) { + checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, undefined); + } + if (!areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) { + error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name)); + } + } + if (node.kind !== 159 && node.kind !== 158) { + checkExportsOnMergedDeclarations(node); + if (node.kind === 242 || node.kind === 191) { + checkVarDeclaredNamesNotShadowed(node); + } + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + if (!compilerOptions.noEmit && languageVersion < 99 && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) { + potentialWeakMapCollisions.push(node); + } + } + } + function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) { + var nextDeclarationName = ts.getNameOfDeclaration(nextDeclaration); + var message = nextDeclaration.kind === 159 || nextDeclaration.kind === 158 + ? ts.Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 + : ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2; + var declName = ts.declarationNameToString(nextDeclarationName); + var err = error(nextDeclarationName, message, declName, typeToString(firstType), typeToString(nextType)); + if (firstDeclaration) { + ts.addRelatedInfo(err, ts.createDiagnosticForNode(firstDeclaration, ts.Diagnostics._0_was_also_declared_here, declName)); + } + } + function areDeclarationFlagsIdentical(left, right) { + if ((left.kind === 156 && right.kind === 242) || + (left.kind === 242 && right.kind === 156)) { + return true; + } + if (ts.hasQuestionToken(left) !== ts.hasQuestionToken(right)) { + return false; + } + var interestingFlags = 8 | + 16 | + 256 | + 128 | + 64 | + 32; + return ts.getSelectedModifierFlags(left, interestingFlags) === ts.getSelectedModifierFlags(right, interestingFlags); + } + function checkVariableDeclaration(node) { + checkGrammarVariableDeclaration(node); + return checkVariableLikeDeclaration(node); + } + function checkBindingElement(node) { + checkGrammarBindingElement(node); + return checkVariableLikeDeclaration(node); + } + function checkVariableStatement(node) { + if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList)) + checkGrammarForDisallowedLetOrConstStatement(node); + ts.forEach(node.declarationList.declarations, checkSourceElement); + } + function checkExpressionStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkExpression(node.expression); + } + function checkIfStatement(node) { + checkGrammarStatementInAmbientContext(node); + var type = checkTruthinessExpression(node.expression); + checkTestingKnownTruthyCallableType(node, type); + checkSourceElement(node.thenStatement); + if (node.thenStatement.kind === 224) { + error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement); + } + checkSourceElement(node.elseStatement); + } + function checkTestingKnownTruthyCallableType(ifStatement, type) { + if (!strictNullChecks) { + return; + } + var testedNode = ts.isIdentifier(ifStatement.expression) + ? ifStatement.expression + : ts.isPropertyAccessExpression(ifStatement.expression) + ? ifStatement.expression.name + : undefined; + if (!testedNode) { + return; + } + var possiblyFalsy = getFalsyFlags(type); + if (possiblyFalsy) { + return; + } + var callSignatures = getSignaturesOfType(type, 0); + if (callSignatures.length === 0) { + return; + } + var testedFunctionSymbol = getSymbolAtLocation(testedNode); + if (!testedFunctionSymbol) { + return; + } + var functionIsUsedInBody = ts.forEachChild(ifStatement.thenStatement, function check(childNode) { + if (ts.isIdentifier(childNode)) { + var childSymbol = getSymbolAtLocation(childNode); + if (childSymbol && childSymbol.id === testedFunctionSymbol.id) { + return true; + } + } + return ts.forEachChild(childNode, check); + }); + if (!functionIsUsedInBody) { + error(ifStatement.expression, ts.Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead); + } + } + function checkDoStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkSourceElement(node.statement); + checkTruthinessExpression(node.expression); + } + function checkWhileStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkTruthinessExpression(node.expression); + checkSourceElement(node.statement); + } + function checkTruthinessOfType(type, node) { + if (type.flags & 16384) { + error(node, ts.Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness); + } + return type; + } + function checkTruthinessExpression(node, checkMode) { + return checkTruthinessOfType(checkExpression(node, checkMode), node); + } + function checkForStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.initializer && node.initializer.kind === 243) { + checkGrammarVariableDeclarationList(node.initializer); + } + } + if (node.initializer) { + if (node.initializer.kind === 243) { + ts.forEach(node.initializer.declarations, checkVariableDeclaration); + } + else { + checkExpression(node.initializer); + } + } + if (node.condition) + checkTruthinessExpression(node.condition); + if (node.incrementor) + checkExpression(node.incrementor); + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForOfStatement(node) { + checkGrammarForInOrForOfStatement(node); + if (node.awaitModifier) { + var functionFlags = ts.getFunctionFlags(ts.getContainingFunction(node)); + if ((functionFlags & (4 | 2)) === 2 && languageVersion < 99) { + checkExternalEmitHelpers(node, 32768); + } + } + else if (compilerOptions.downlevelIteration && languageVersion < 2) { + checkExternalEmitHelpers(node, 256); + } + if (node.initializer.kind === 243) { + checkForInOrForOfVariableDeclaration(node); + } + else { + var varExpr = node.initializer; + var iteratedType = checkRightHandSideOfForOf(node.expression, node.awaitModifier); + if (varExpr.kind === 192 || varExpr.kind === 193) { + checkDestructuringAssignment(varExpr, iteratedType || errorType); + } + else { + var leftType = checkExpression(varExpr); + checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access); + if (iteratedType) { + checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression); + } + } + } + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForInStatement(node) { + checkGrammarForInOrForOfStatement(node); + var rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression)); + if (node.initializer.kind === 243) { + var variable = node.initializer.declarations[0]; + if (variable && ts.isBindingPattern(variable.name)) { + error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); + } + checkForInOrForOfVariableDeclaration(node); + } + else { + var varExpr = node.initializer; + var leftType = checkExpression(varExpr); + if (varExpr.kind === 192 || varExpr.kind === 193) { + error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); + } + else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) { + error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any); + } + else { + checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access); + } + } + if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 | 58982400)) { + error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType)); + } + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForInOrForOfVariableDeclaration(iterationStatement) { + var variableDeclarationList = iterationStatement.initializer; + if (variableDeclarationList.declarations.length >= 1) { + var decl = variableDeclarationList.declarations[0]; + checkVariableDeclaration(decl); + } + } + function checkRightHandSideOfForOf(rhsExpression, awaitModifier) { + var expressionType = checkNonNullExpression(rhsExpression); + var use = awaitModifier ? 15 : 13; + return checkIteratedTypeOrElementType(use, expressionType, undefinedType, rhsExpression); + } + function checkIteratedTypeOrElementType(use, inputType, sentType, errorNode) { + if (isTypeAny(inputType)) { + return inputType; + } + return getIteratedTypeOrElementType(use, inputType, sentType, errorNode, true) || anyType; + } + function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) { + var allowAsyncIterables = (use & 2) !== 0; + if (inputType === neverType) { + reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables); + return undefined; + } + var uplevelIteration = languageVersion >= 2; + var downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration; + if (uplevelIteration || downlevelIteration || allowAsyncIterables) { + var iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : undefined); + if (checkAssignability) { + if (iterationTypes) { + var diagnostic = use & 8 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 : + use & 32 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 : + use & 64 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 : + use & 16 ? ts.Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 : + undefined; + if (diagnostic) { + checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic); + } + } + } + if (iterationTypes || uplevelIteration) { + return iterationTypes && iterationTypes.yieldType; + } + } + var arrayType = inputType; + var reportedError = false; + var hasStringConstituent = false; + if (use & 4) { + if (arrayType.flags & 1048576) { + var arrayTypes = inputType.types; + var filteredTypes = ts.filter(arrayTypes, function (t) { return !(t.flags & 132); }); + if (filteredTypes !== arrayTypes) { + arrayType = getUnionType(filteredTypes, 2); + } + } + else if (arrayType.flags & 132) { + arrayType = neverType; + } + hasStringConstituent = arrayType !== inputType; + if (hasStringConstituent) { + if (languageVersion < 1) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); + reportedError = true; + } + } + if (arrayType.flags & 131072) { + return stringType; + } + } + } + if (!isArrayLikeType(arrayType)) { + if (errorNode && !reportedError) { + var yieldType = getIterationTypeOfIterable(use, 0, inputType, undefined); + var _a = !(use & 4) || hasStringConstituent + ? downlevelIteration + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true] + : yieldType + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false] + : [ts.Diagnostics.Type_0_is_not_an_array_type, true] + : downlevelIteration + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true] + : yieldType + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false] + : [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true], defaultDiagnostic = _a[0], maybeMissingAwait = _a[1]; + errorAndMaybeSuggestAwait(errorNode, maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType), defaultDiagnostic, typeToString(arrayType)); + } + return hasStringConstituent ? stringType : undefined; + } + var arrayElementType = getIndexTypeOfType(arrayType, 1); + if (hasStringConstituent && arrayElementType) { + if (arrayElementType.flags & 132) { + return stringType; + } + return getUnionType([arrayElementType, stringType], 2); + } + return arrayElementType; + } + function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) { + if (isTypeAny(inputType)) { + return undefined; + } + var iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode); + return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)]; + } + function createIterationTypes(yieldType, returnType, nextType) { + if (yieldType === void 0) { yieldType = neverType; } + if (returnType === void 0) { returnType = neverType; } + if (nextType === void 0) { nextType = unknownType; } + if (yieldType.flags & 67359327 && + returnType.flags & (1 | 131072 | 2 | 16384 | 32768) && + nextType.flags & (1 | 131072 | 2 | 16384 | 32768)) { + var id = getTypeListId([yieldType, returnType, nextType]); + var iterationTypes = iterationTypesCache.get(id); + if (!iterationTypes) { + iterationTypes = { yieldType: yieldType, returnType: returnType, nextType: nextType }; + iterationTypesCache.set(id, iterationTypes); + } + return iterationTypes; + } + return { yieldType: yieldType, returnType: returnType, nextType: nextType }; + } + function combineIterationTypes(array) { + var yieldTypes; + var returnTypes; + var nextTypes; + for (var _i = 0, array_10 = array; _i < array_10.length; _i++) { + var iterationTypes = array_10[_i]; + if (iterationTypes === undefined || iterationTypes === noIterationTypes) { + continue; + } + if (iterationTypes === anyIterationTypes) { + return anyIterationTypes; + } + yieldTypes = ts.append(yieldTypes, iterationTypes.yieldType); + returnTypes = ts.append(returnTypes, iterationTypes.returnType); + nextTypes = ts.append(nextTypes, iterationTypes.nextType); + } + if (yieldTypes || returnTypes || nextTypes) { + return createIterationTypes(yieldTypes && getUnionType(yieldTypes), returnTypes && getUnionType(returnTypes), nextTypes && getIntersectionType(nextTypes)); + } + return noIterationTypes; + } + function getCachedIterationTypes(type, cacheKey) { + return type[cacheKey]; + } + function setCachedIterationTypes(type, cacheKey, cachedTypes) { + return type[cacheKey] = cachedTypes; + } + function getIterationTypesOfIterable(type, use, errorNode) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + if (!(type.flags & 1048576)) { + var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode); + if (iterationTypes_1 === noIterationTypes) { + if (errorNode) { + reportTypeNotIterableError(errorNode, type, !!(use & 2)); + } + return undefined; + } + return iterationTypes_1; + } + var cacheKey = use & 2 ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable"; + var cachedTypes = getCachedIterationTypes(type, cacheKey); + if (cachedTypes) + return cachedTypes === noIterationTypes ? undefined : cachedTypes; + var allIterationTypes; + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var constituent = _a[_i]; + var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode); + if (iterationTypes_2 === noIterationTypes) { + if (errorNode) { + reportTypeNotIterableError(errorNode, type, !!(use & 2)); + errorNode = undefined; + } + } + else { + allIterationTypes = ts.append(allIterationTypes, iterationTypes_2); + } + } + var iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes; + setCachedIterationTypes(type, cacheKey, iterationTypes); + return iterationTypes === noIterationTypes ? undefined : iterationTypes; + } + function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) { + if (iterationTypes === noIterationTypes) + return noIterationTypes; + if (iterationTypes === anyIterationTypes) + return anyIterationTypes; + var yieldType = iterationTypes.yieldType, returnType = iterationTypes.returnType, nextType = iterationTypes.nextType; + return createIterationTypes(getAwaitedType(yieldType, errorNode) || anyType, getAwaitedType(returnType, errorNode) || anyType, nextType); + } + function getIterationTypesOfIterableWorker(type, use, errorNode) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + if (use & 2) { + var iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || + getIterationTypesOfIterableFast(type, asyncIterationTypesResolver); + if (iterationTypes) { + return iterationTypes; + } + } + if (use & 1) { + var iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) || + getIterationTypesOfIterableFast(type, syncIterationTypesResolver); + if (iterationTypes) { + if (use & 2) { + if (iterationTypes !== noIterationTypes) { + return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", getAsyncFromSyncIterationTypes(iterationTypes, errorNode)); + } + } + else { + return iterationTypes; + } + } + } + if (use & 2) { + var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode); + if (iterationTypes !== noIterationTypes) { + return iterationTypes; + } + } + if (use & 1) { + var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode); + if (iterationTypes !== noIterationTypes) { + if (use & 2) { + return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes + ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode) + : noIterationTypes); + } + else { + return iterationTypes; + } + } + } + return noIterationTypes; + } + function getIterationTypesOfIterableCached(type, resolver) { + return getCachedIterationTypes(type, resolver.iterableCacheKey); + } + function getIterationTypesOfGlobalIterableType(globalType, resolver) { + var globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || + getIterationTypesOfIterableSlow(globalType, resolver, undefined); + return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes; + } + function getIterationTypesOfIterableFast(type, resolver) { + var globalType; + if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(false)) || + isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(false))) { + var yieldType = getTypeArguments(type)[0]; + var _a = getIterationTypesOfGlobalIterableType(globalType, resolver), returnType = _a.returnType, nextType = _a.nextType; + return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + if (isReferenceToType(type, resolver.getGlobalGeneratorType(false))) { + var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2]; + return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + } + function getIterationTypesOfIterableSlow(type, resolver, errorNode) { + var _a; + var method = getPropertyOfType(type, ts.getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName)); + var methodType = method && !(method.flags & 16777216) ? getTypeOfSymbol(method) : undefined; + if (isTypeAny(methodType)) { + return setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes); + } + var signatures = methodType ? getSignaturesOfType(methodType, 0) : undefined; + if (!ts.some(signatures)) { + return setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes); + } + var iteratorType = getUnionType(ts.map(signatures, getReturnTypeOfSignature), 2); + var iterationTypes = (_a = getIterationTypesOfIterator(iteratorType, resolver, errorNode)) !== null && _a !== void 0 ? _a : noIterationTypes; + return setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes); + } + function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) { + var message = allowAsyncIterables + ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator + : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator; + errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type)); + } + function getIterationTypesOfIterator(type, resolver, errorNode) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var iterationTypes = getIterationTypesOfIteratorCached(type, resolver) || + getIterationTypesOfIteratorFast(type, resolver) || + getIterationTypesOfIteratorSlow(type, resolver, errorNode); + return iterationTypes === noIterationTypes ? undefined : iterationTypes; + } + function getIterationTypesOfIteratorCached(type, resolver) { + return getCachedIterationTypes(type, resolver.iteratorCacheKey); + } + function getIterationTypesOfIteratorFast(type, resolver) { + var globalType = resolver.getGlobalIterableIteratorType(false); + if (isReferenceToType(type, globalType)) { + var yieldType = getTypeArguments(type)[0]; + var globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || + getIterationTypesOfIteratorSlow(globalType, resolver, undefined); + var _a = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes, returnType = _a.returnType, nextType = _a.nextType; + return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + if (isReferenceToType(type, resolver.getGlobalIteratorType(false)) || + isReferenceToType(type, resolver.getGlobalGeneratorType(false))) { + var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2]; + return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + } + function isIteratorResult(type, kind) { + var doneType = getTypeOfPropertyOfType(type, "done") || falseType; + return isTypeAssignableTo(kind === 0 ? falseType : trueType, doneType); + } + function isYieldIteratorResult(type) { + return isIteratorResult(type, 0); + } + function isReturnIteratorResult(type) { + return isIteratorResult(type, 1); + } + function getIterationTypesOfIteratorResult(type) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var cachedTypes = getCachedIterationTypes(type, "iterationTypesOfIteratorResult"); + if (cachedTypes) { + return cachedTypes; + } + if (isReferenceToType(type, getGlobalIteratorYieldResultType(false))) { + var yieldType_1 = getTypeArguments(type)[0]; + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType_1, undefined, undefined)); + } + if (isReferenceToType(type, getGlobalIteratorReturnResultType(false))) { + var returnType_1 = getTypeArguments(type)[0]; + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(undefined, returnType_1, undefined)); + } + var yieldIteratorResult = filterType(type, isYieldIteratorResult); + var yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : undefined; + var returnIteratorResult = filterType(type, isReturnIteratorResult); + var returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : undefined; + if (!yieldType && !returnType) { + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes); + } + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, undefined)); + } + function getIterationTypesOfMethod(type, resolver, methodName, errorNode) { + var method = getPropertyOfType(type, methodName); + if (!method && methodName !== "next") { + return undefined; + } + var methodType = method && !(methodName === "next" && (method.flags & 16777216)) + ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152) + : undefined; + if (isTypeAny(methodType)) { + return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext; + } + var methodSignatures = methodType ? getSignaturesOfType(methodType, 0) : ts.emptyArray; + if (methodSignatures.length === 0) { + if (errorNode) { + var diagnostic = methodName === "next" + ? resolver.mustHaveANextMethodDiagnostic + : resolver.mustBeAMethodDiagnostic; + error(errorNode, diagnostic, methodName); + } + return methodName === "next" ? anyIterationTypes : undefined; + } + var methodParameterTypes; + var methodReturnTypes; + for (var _i = 0, methodSignatures_1 = methodSignatures; _i < methodSignatures_1.length; _i++) { + var signature = methodSignatures_1[_i]; + if (methodName !== "throw" && ts.some(signature.parameters)) { + methodParameterTypes = ts.append(methodParameterTypes, getTypeAtPosition(signature, 0)); + } + methodReturnTypes = ts.append(methodReturnTypes, getReturnTypeOfSignature(signature)); + } + var returnTypes; + var nextType; + if (methodName !== "throw") { + var methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType; + if (methodName === "next") { + nextType = methodParameterType; + } + else if (methodName === "return") { + var resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType; + returnTypes = ts.append(returnTypes, resolvedMethodParameterType); + } + } + var yieldType; + var methodReturnType = methodReturnTypes ? getUnionType(methodReturnTypes, 2) : neverType; + var resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType; + var iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType); + if (iterationTypes === noIterationTypes) { + if (errorNode) { + error(errorNode, resolver.mustHaveAValueDiagnostic, methodName); + } + yieldType = anyType; + returnTypes = ts.append(returnTypes, anyType); + } + else { + yieldType = iterationTypes.yieldType; + returnTypes = ts.append(returnTypes, iterationTypes.returnType); + } + return createIterationTypes(yieldType, getUnionType(returnTypes), nextType); + } + function getIterationTypesOfIteratorSlow(type, resolver, errorNode) { + var iterationTypes = combineIterationTypes([ + getIterationTypesOfMethod(type, resolver, "next", errorNode), + getIterationTypesOfMethod(type, resolver, "return", errorNode), + getIterationTypesOfMethod(type, resolver, "throw", errorNode), + ]); + return setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes); + } + function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) { + if (isTypeAny(returnType)) { + return undefined; + } + var iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator); + return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)]; + } + function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var use = isAsyncGenerator ? 2 : 1; + var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver; + return getIterationTypesOfIterable(type, use, undefined) || + getIterationTypesOfIterator(type, resolver, undefined); + } + function checkBreakOrContinueStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) + checkGrammarBreakOrContinueStatement(node); + } + function unwrapReturnType(returnType, functionFlags) { + var isGenerator = !!(functionFlags & 1); + var isAsync = !!(functionFlags & 2); + return isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(1, returnType, isAsync) || errorType : + isAsync ? getPromisedTypeOfPromise(returnType) || errorType : + returnType; + } + function isUnwrappedReturnTypeVoidOrAny(func, returnType) { + var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func)); + return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 | 3); + } + function checkReturnStatement(node) { + if (checkGrammarStatementInAmbientContext(node)) { + return; + } + var func = ts.getContainingFunction(node); + if (!func) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body); + return; + } + var signature = getSignatureFromDeclaration(func); + var returnType = getReturnTypeOfSignature(signature); + var functionFlags = ts.getFunctionFlags(func); + if (strictNullChecks || node.expression || returnType.flags & 131072) { + var exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType; + if (func.kind === 164) { + if (node.expression) { + error(node, ts.Diagnostics.Setters_cannot_return_a_value); + } + } + else if (func.kind === 162) { + if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) { + error(node, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); + } + } + else if (getReturnTypeFromAnnotation(func)) { + var unwrappedReturnType = unwrapReturnType(returnType, functionFlags); + var unwrappedExprType = functionFlags & 2 + ? checkAwaitedType(exprType, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member) + : exprType; + if (unwrappedReturnType) { + checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression); + } + } + } + else if (func.kind !== 162 && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) { + error(node, ts.Diagnostics.Not_all_code_paths_return_a_value); + } + } + function checkWithStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.flags & 32768) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_an_async_function_block); + } + } + checkExpression(node.expression); + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var start = ts.getSpanOfTokenAtPosition(sourceFile, node.pos).start; + var end = node.statement.pos; + grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any); + } + } + function checkSwitchStatement(node) { + checkGrammarStatementInAmbientContext(node); + var firstDefaultClause; + var hasDuplicateDefaultClause = false; + var expressionType = checkExpression(node.expression); + var expressionIsLiteral = isLiteralType(expressionType); + ts.forEach(node.caseBlock.clauses, function (clause) { + if (clause.kind === 278 && !hasDuplicateDefaultClause) { + if (firstDefaultClause === undefined) { + firstDefaultClause = clause; + } + else { + grammarErrorOnNode(clause, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement); + hasDuplicateDefaultClause = true; + } + } + if (produceDiagnostics && clause.kind === 277) { + var caseType = checkExpression(clause.expression); + var caseIsLiteral = isLiteralType(caseType); + var comparedExpressionType = expressionType; + if (!caseIsLiteral || !expressionIsLiteral) { + caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType; + comparedExpressionType = getBaseTypeOfLiteralType(expressionType); + } + if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) { + checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, undefined); + } + } + ts.forEach(clause.statements, checkSourceElement); + if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) { + error(clause, ts.Diagnostics.Fallthrough_case_in_switch); + } + }); + if (node.caseBlock.locals) { + registerForUnusedIdentifiersCheck(node.caseBlock); + } + } + function checkLabeledStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + ts.findAncestor(node.parent, function (current) { + if (ts.isFunctionLike(current)) { + return "quit"; + } + if (current.kind === 238 && current.label.escapedText === node.label.escapedText) { + grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNode(node.label)); + return true; + } + return false; + }); + } + checkSourceElement(node.statement); + } + function checkThrowStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.expression === undefined) { + grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here); + } + } + if (node.expression) { + checkExpression(node.expression); + } + } + function checkTryStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkBlock(node.tryBlock); + var catchClause = node.catchClause; + if (catchClause) { + if (catchClause.variableDeclaration) { + if (catchClause.variableDeclaration.type) { + grammarErrorOnFirstToken(catchClause.variableDeclaration.type, ts.Diagnostics.Catch_clause_variable_cannot_have_a_type_annotation); + } + else if (catchClause.variableDeclaration.initializer) { + grammarErrorOnFirstToken(catchClause.variableDeclaration.initializer, ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer); + } + else { + var blockLocals_1 = catchClause.block.locals; + if (blockLocals_1) { + ts.forEachKey(catchClause.locals, function (caughtName) { + var blockLocal = blockLocals_1.get(caughtName); + if (blockLocal && (blockLocal.flags & 2) !== 0) { + grammarErrorOnNode(blockLocal.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName); + } + }); + } + } + } + checkBlock(catchClause.block); + } + if (node.finallyBlock) { + checkBlock(node.finallyBlock); + } + } + function checkIndexConstraints(type) { + var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1); + var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); + if (stringIndexType || numberIndexType) { + ts.forEach(getPropertiesOfObjectType(type), function (prop) { + var propType = getTypeOfSymbol(prop); + checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); + }); + var classDeclaration = type.symbol.valueDeclaration; + if (ts.getObjectFlags(type) & 1 && ts.isClassLike(classDeclaration)) { + for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (!ts.hasModifier(member, 32) && hasNonBindableDynamicName(member)) { + var symbol = getSymbolOfNode(member); + var propType = getTypeOfSymbol(symbol); + checkIndexConstraintForProperty(symbol, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(symbol, propType, type, declaredNumberIndexer, numberIndexType, 1); + } + } + } + } + var errorNode; + if (stringIndexType && numberIndexType) { + errorNode = declaredNumberIndexer || declaredStringIndexer; + if (!errorNode && (ts.getObjectFlags(type) & 2)) { + var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0) && getIndexTypeOfType(base, 1); }); + errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0]; + } + } + if (errorNode && !isTypeAssignableTo(numberIndexType, stringIndexType)) { + error(errorNode, ts.Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1, typeToString(numberIndexType), typeToString(stringIndexType)); + } + function checkIndexConstraintForProperty(prop, propertyType, containingType, indexDeclaration, indexType, indexKind) { + if (!indexType || ts.isKnownSymbol(prop)) { + return; + } + var propDeclaration = prop.valueDeclaration; + var name = propDeclaration && ts.getNameOfDeclaration(propDeclaration); + if (indexKind === 1 && !(name ? isNumericName(name) : isNumericLiteralName(prop.escapedName))) { + return; + } + var errorNode; + if (propDeclaration && name && + (propDeclaration.kind === 209 || + name.kind === 154 || + prop.parent === containingType.symbol)) { + errorNode = propDeclaration; + } + else if (indexDeclaration) { + errorNode = indexDeclaration; + } + else if (ts.getObjectFlags(containingType) & 2) { + var someBaseClassHasBothPropertyAndIndexer = ts.forEach(getBaseTypes(containingType), function (base) { return getPropertyOfObjectType(base, prop.escapedName) && getIndexTypeOfType(base, indexKind); }); + errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0]; + } + if (errorNode && !isTypeAssignableTo(propertyType, indexType)) { + var errorMessage = indexKind === 0 + ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2 + : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2; + error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType)); + } + } + } + function checkTypeNameIsReserved(name, message) { + switch (name.escapedText) { + case "any": + case "unknown": + case "number": + case "bigint": + case "boolean": + case "string": + case "symbol": + case "void": + case "object": + error(name, message, name.escapedText); + } + } + function checkClassNameCollisionWithObject(name) { + if (languageVersion === 1 && name.escapedText === "Object" + && moduleKind < ts.ModuleKind.ES2015) { + error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]); + } + } + function checkTypeParameters(typeParameterDeclarations) { + if (typeParameterDeclarations) { + var seenDefault = false; + for (var i = 0; i < typeParameterDeclarations.length; i++) { + var node = typeParameterDeclarations[i]; + checkTypeParameter(node); + if (produceDiagnostics) { + if (node.default) { + seenDefault = true; + checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i); + } + else if (seenDefault) { + error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters); + } + for (var j = 0; j < i; j++) { + if (typeParameterDeclarations[j].symbol === node.symbol) { + error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name)); + } + } + } + } + } + } + function checkTypeParametersNotReferenced(root, typeParameters, index) { + visit(root); + function visit(node) { + if (node.kind === 169) { + var type = getTypeFromTypeReference(node); + if (type.flags & 262144) { + for (var i = index; i < typeParameters.length; i++) { + if (type.symbol === getSymbolOfNode(typeParameters[i])) { + error(node, ts.Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters); + } + } + } + } + ts.forEachChild(node, visit); + } + } + function checkTypeParameterListsIdentical(symbol) { + if (symbol.declarations.length === 1) { + return; + } + var links = getSymbolLinks(symbol); + if (!links.typeParametersChecked) { + links.typeParametersChecked = true; + var declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol); + if (declarations.length <= 1) { + return; + } + var type = getDeclaredTypeOfSymbol(symbol); + if (!areTypeParametersIdentical(declarations, type.localTypeParameters)) { + var name = symbolToString(symbol); + for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) { + var declaration = declarations_6[_i]; + error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name); + } + } + } + } + function areTypeParametersIdentical(declarations, targetParameters) { + var maxTypeArgumentCount = ts.length(targetParameters); + var minTypeArgumentCount = getMinTypeArgumentCount(targetParameters); + for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) { + var declaration = declarations_7[_i]; + var sourceParameters = ts.getEffectiveTypeParameterDeclarations(declaration); + var numTypeParameters = sourceParameters.length; + if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) { + return false; + } + for (var i = 0; i < numTypeParameters; i++) { + var source = sourceParameters[i]; + var target = targetParameters[i]; + if (source.name.escapedText !== target.symbol.escapedName) { + return false; + } + var constraint = ts.getEffectiveConstraintOfTypeParameter(source); + var sourceConstraint = constraint && getTypeFromTypeNode(constraint); + var targetConstraint = getConstraintOfTypeParameter(target); + if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) { + return false; + } + var sourceDefault = source.default && getTypeFromTypeNode(source.default); + var targetDefault = getDefaultFromTypeParameter(target); + if (sourceDefault && targetDefault && !isTypeIdenticalTo(sourceDefault, targetDefault)) { + return false; + } + } + } + return true; + } + function checkClassExpression(node) { + checkClassLikeDeclaration(node); + checkNodeDeferred(node); + return getTypeOfSymbol(getSymbolOfNode(node)); + } + function checkClassExpressionDeferred(node) { + ts.forEach(node.members, checkSourceElement); + registerForUnusedIdentifiersCheck(node); + } + function checkClassDeclaration(node) { + if (!node.name && !ts.hasModifier(node, 512)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); + } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + registerForUnusedIdentifiersCheck(node); + } + function checkClassLikeDeclaration(node) { + checkGrammarClassLikeDeclaration(node); + checkDecorators(node); + if (node.name) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Class_name_cannot_be_0); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + if (!(node.flags & 8388608)) { + checkClassNameCollisionWithObject(node.name); + } + } + checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node)); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + var type = getDeclaredTypeOfSymbol(symbol); + var typeWithThis = getTypeWithThisArgument(type); + var staticType = getTypeOfSymbol(symbol); + checkTypeParameterListsIdentical(symbol); + checkClassForDuplicateDeclarations(node); + if (!(node.flags & 8388608)) { + checkClassForStaticPropertyNameConflicts(node); + } + var baseTypeNode = ts.getEffectiveBaseTypeNode(node); + if (baseTypeNode) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + if (languageVersion < 2) { + checkExternalEmitHelpers(baseTypeNode.parent, 1); + } + var extendsNode = ts.getClassExtendsHeritageElement(node); + if (extendsNode && extendsNode !== baseTypeNode) { + checkExpression(extendsNode.expression); + } + var baseTypes = getBaseTypes(type); + if (baseTypes.length && produceDiagnostics) { + var baseType_1 = baseTypes[0]; + var baseConstructorType = getBaseConstructorTypeOfClass(type); + var staticBaseType = getApparentType(baseConstructorType); + checkBaseTypeAccessibility(staticBaseType, baseTypeNode); + checkSourceElement(baseTypeNode.expression); + if (ts.some(baseTypeNode.typeArguments)) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) { + break; + } + } + } + var baseWithThis = getTypeWithThisArgument(baseType_1, type.thisType); + if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) { + issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); + } + else { + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + } + if (baseConstructorType.flags & 8650752 && !isMixinConstructorType(staticType)) { + error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any); + } + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32) && !(baseConstructorType.flags & 8650752)) { + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); + if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType_1); })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } + } + checkKindsOfPropertyMemberOverrides(type, baseType_1); + } + } + var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); + if (implementedTypeNodes) { + for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) { + var typeRefNode = implementedTypeNodes_1[_b]; + if (!ts.isEntityNameExpression(typeRefNode.expression)) { + error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); + } + checkTypeReferenceNode(typeRefNode); + if (produceDiagnostics) { + var t = getTypeFromTypeNode(typeRefNode); + if (t !== errorType) { + if (isValidBaseType(t)) { + var genericDiag = t.symbol && t.symbol.flags & 32 ? + ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass : + ts.Diagnostics.Class_0_incorrectly_implements_interface_1; + var baseWithThis = getTypeWithThisArgument(t, type.thisType); + if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) { + issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag); + } + } + else { + error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members); + } + } + } + } + } + if (produceDiagnostics) { + checkIndexConstraints(type); + checkTypeForDuplicateIndexSignatures(node); + checkPropertyInitialization(node); + } + } + function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) { + var issuedMemberError = false; + var _loop_17 = function (member) { + if (ts.hasStaticModifier(member)) { + return "continue"; + } + var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member); + if (declaredProp) { + var prop = getPropertyOfType(typeWithThis, declaredProp.escapedName); + var baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName); + if (prop && baseProp) { + var rootChain = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2, symbolToString(declaredProp), typeToString(typeWithThis), typeToString(baseWithThis)); }; + if (!checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(baseProp), member.name || member, undefined, rootChain)) { + issuedMemberError = true; + } + } + } + }; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + _loop_17(member); + } + if (!issuedMemberError) { + checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag); + } + } + function checkBaseTypeAccessibility(type, node) { + var signatures = getSignaturesOfType(type, 1); + if (signatures.length) { + var declaration = signatures[0].declaration; + if (declaration && ts.hasModifier(declaration, 8)) { + var typeClassDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol); + if (!isNodeWithinClass(node, typeClassDeclaration)) { + error(node, ts.Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol)); + } + } + } + } + function getTargetSymbol(s) { + return ts.getCheckFlags(s) & 1 ? s.target : s; + } + function getClassOrInterfaceDeclarationsOfSymbol(symbol) { + return ts.filter(symbol.declarations, function (d) { + return d.kind === 245 || d.kind === 246; + }); + } + function checkKindsOfPropertyMemberOverrides(type, baseType) { + var baseProperties = getPropertiesOfType(baseType); + basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) { + var baseProperty = baseProperties_1[_i]; + var base = getTargetSymbol(baseProperty); + if (base.flags & 4194304) { + continue; + } + var baseSymbol = getPropertyOfObjectType(type, base.escapedName); + if (!baseSymbol) { + continue; + } + var derived = getTargetSymbol(baseSymbol); + var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base); + ts.Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration."); + if (derived === base) { + var derivedClassDecl = ts.getClassLikeDeclarationOfSymbol(type.symbol); + if (baseDeclarationFlags & 128 && (!derivedClassDecl || !ts.hasModifier(derivedClassDecl, 128))) { + for (var _a = 0, _b = getBaseTypes(type); _a < _b.length; _a++) { + var otherBaseType = _b[_a]; + if (otherBaseType === baseType) + continue; + var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName); + var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1); + if (derivedElsewhere && derivedElsewhere !== base) { + continue basePropertyCheck; + } + } + if (derivedClassDecl.kind === 214) { + error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType)); + } + else { + error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType)); + } + } + } + else { + var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived); + if (baseDeclarationFlags & 8 || derivedDeclarationFlags & 8) { + continue; + } + var errorMessage = void 0; + var basePropertyFlags = base.flags & 98308; + var derivedPropertyFlags = derived.flags & 98308; + if (basePropertyFlags && derivedPropertyFlags) { + if (!compilerOptions.useDefineForClassFields + || baseDeclarationFlags & 128 && !(base.valueDeclaration && ts.isPropertyDeclaration(base.valueDeclaration) && base.valueDeclaration.initializer) + || base.valueDeclaration && base.valueDeclaration.parent.kind === 246 + || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) { + continue; + } + var overriddenInstanceProperty = basePropertyFlags !== 4 && derivedPropertyFlags === 4; + var overriddenInstanceAccessor = basePropertyFlags === 4 && derivedPropertyFlags !== 4; + if (overriddenInstanceProperty || overriddenInstanceAccessor) { + var errorMessage_1 = overriddenInstanceProperty ? + ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : + ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor; + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type)); + } + else { + var uninitialized = ts.find(derived.declarations, function (d) { return d.kind === 159 && !d.initializer; }); + if (uninitialized + && !(derived.flags & 33554432) + && !(baseDeclarationFlags & 128) + && !(derivedDeclarationFlags & 128) + && !derived.declarations.some(function (d) { return !!(d.flags & 8388608); })) { + var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol)); + var propName = uninitialized.name; + if (uninitialized.exclamationToken + || !constructor + || !ts.isIdentifier(propName) + || !strictNullChecks + || !isPropertyInitializedInConstructor(propName, type, constructor)) { + var errorMessage_2 = ts.Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration; + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_2, symbolToString(base), typeToString(baseType)); + } + } + } + continue; + } + else if (isPrototypeProperty(base)) { + if (isPrototypeProperty(derived) || derived.flags & 4) { + continue; + } + else { + ts.Debug.assert(!!(derived.flags & 98304)); + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } + } + else if (base.flags & 98304) { + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; + } + else { + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + } + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type)); + } + } + } + function checkInheritedPropertiesAreIdentical(type, typeNode) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length < 2) { + return true; + } + var seen = ts.createUnderscoreEscapedMap(); + ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen.set(p.escapedName, { prop: p, containingType: type }); }); + var ok = true; + for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) { + var base = baseTypes_2[_i]; + var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType)); + for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) { + var prop = properties_4[_a]; + var existing = seen.get(prop.escapedName); + if (!existing) { + seen.set(prop.escapedName, { prop: prop, containingType: base }); + } + else { + var isInheritedProperty = existing.containingType !== type; + if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) { + ok = false; + var typeName1 = typeToString(existing.containingType); + var typeName2 = typeToString(base); + var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo)); + } + } + } + } + return ok; + } + function checkPropertyInitialization(node) { + if (!strictNullChecks || !strictPropertyInitialization || node.flags & 8388608) { + return; + } + var constructor = findConstructorDeclaration(node); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.getModifierFlags(member) & 2) { + continue; + } + if (isInstancePropertyWithoutInitializer(member)) { + var propName = member.name; + if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) { + var type = getTypeOfSymbol(getSymbolOfNode(member)); + if (!(type.flags & 3 || getFalsyFlags(type) & 32768)) { + if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) { + error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName)); + } + } + } + } + } + } + function isInstancePropertyWithoutInitializer(node) { + return node.kind === 159 && + !ts.hasModifier(node, 32 | 128) && + !node.exclamationToken && + !node.initializer; + } + function isPropertyInitializedInConstructor(propName, propType, constructor) { + var reference = ts.createPropertyAccess(ts.createThis(), propName); + reference.expression.parent = reference; + reference.parent = constructor; + reference.flowNode = constructor.returnFlowNode; + var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType)); + return !(getFalsyFlags(flowType) & 32768); + } + function checkInterfaceDeclaration(node) { + if (!checkGrammarDecoratorsAndModifiers(node)) + checkGrammarInterfaceDeclaration(node); + checkTypeParameters(node.typeParameters); + if (produceDiagnostics) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + checkTypeParameterListsIdentical(symbol); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 246); + if (node === firstInterfaceDecl) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeWithThis = getTypeWithThisArgument(type); + if (checkInheritedPropertiesAreIdentical(type, node.name)) { + for (var _i = 0, _a = getBaseTypes(type); _i < _a.length; _i++) { + var baseType = _a[_i]; + checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1); + } + checkIndexConstraints(type); + } + } + checkObjectTypeForDuplicateDeclarations(node); + } + ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) { + if (!ts.isEntityNameExpression(heritageElement.expression)) { + error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); + } + checkTypeReferenceNode(heritageElement); + }); + ts.forEach(node.members, checkSourceElement); + if (produceDiagnostics) { + checkTypeForDuplicateIndexSignatures(node); + registerForUnusedIdentifiersCheck(node); + } + } + function checkTypeAliasDeclaration(node) { + checkGrammarDecoratorsAndModifiers(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); + checkExportsOnMergedDeclarations(node); + checkTypeParameters(node.typeParameters); + checkSourceElement(node.type); + registerForUnusedIdentifiersCheck(node); + } + function computeEnumMemberValues(node) { + var nodeLinks = getNodeLinks(node); + if (!(nodeLinks.flags & 16384)) { + nodeLinks.flags |= 16384; + var autoValue = 0; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + var value = computeMemberValue(member, autoValue); + getNodeLinks(member).enumMemberValue = value; + autoValue = typeof value === "number" ? value + 1 : undefined; + } + } + } + function computeMemberValue(member, autoValue) { + if (isComputedNonLiteralName(member.name)) { + error(member.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); + } + else { + var text = ts.getTextOfPropertyName(member.name); + if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) { + error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); + } + } + if (member.initializer) { + return computeConstantValue(member); + } + if (member.parent.flags & 8388608 && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0) { + return undefined; + } + if (autoValue !== undefined) { + return autoValue; + } + error(member.name, ts.Diagnostics.Enum_member_must_have_initializer); + return undefined; + } + function computeConstantValue(member) { + var enumKind = getEnumKind(getSymbolOfNode(member.parent)); + var isConstEnum = ts.isEnumConst(member.parent); + var initializer = member.initializer; + var value = enumKind === 1 && !isLiteralEnumMember(member) ? undefined : evaluate(initializer); + if (value !== undefined) { + if (isConstEnum && typeof value === "number" && !isFinite(value)) { + error(initializer, isNaN(value) ? + ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : + ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value); + } + } + else if (enumKind === 1) { + error(initializer, ts.Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members); + return 0; + } + else if (isConstEnum) { + error(initializer, ts.Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values); + } + else if (member.parent.flags & 8388608) { + error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression); + } + else { + checkTypeAssignableTo(checkExpression(initializer), getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, undefined); + } + return value; + function evaluate(expr) { + switch (expr.kind) { + case 207: + var value_2 = evaluate(expr.operand); + if (typeof value_2 === "number") { + switch (expr.operator) { + case 39: return value_2; + case 40: return -value_2; + case 54: return ~value_2; + } + } + break; + case 209: + var left = evaluate(expr.left); + var right = evaluate(expr.right); + if (typeof left === "number" && typeof right === "number") { + switch (expr.operatorToken.kind) { + case 51: return left | right; + case 50: return left & right; + case 48: return left >> right; + case 49: return left >>> right; + case 47: return left << right; + case 52: return left ^ right; + case 41: return left * right; + case 43: return left / right; + case 39: return left + right; + case 40: return left - right; + case 44: return left % right; + case 42: return Math.pow(left, right); + } + } + else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39) { + return left + right; + } + break; + case 10: + case 14: + return expr.text; + case 8: + checkGrammarNumericLiteral(expr); + return +expr.text; + case 200: + return evaluate(expr.expression); + case 75: + var identifier = expr; + if (isInfinityOrNaNString(identifier.escapedText)) { + return +(identifier.escapedText); + } + return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText); + case 195: + case 194: + var ex = expr; + if (isConstantMemberAccess(ex)) { + var type = getTypeOfExpression(ex.expression); + if (type.symbol && type.symbol.flags & 384) { + var name = void 0; + if (ex.kind === 194) { + name = ex.name.escapedText; + } + else { + name = ts.escapeLeadingUnderscores(ts.cast(ex.argumentExpression, ts.isLiteralExpression).text); + } + return evaluateEnumMember(expr, type.symbol, name); + } + } + break; + } + return undefined; + } + function evaluateEnumMember(expr, enumSymbol, name) { + var memberSymbol = enumSymbol.exports.get(name); + if (memberSymbol) { + var declaration = memberSymbol.valueDeclaration; + if (declaration !== member) { + if (isBlockScopedNameDeclaredBeforeUse(declaration, member)) { + return getEnumMemberValue(declaration); + } + error(expr, ts.Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums); + return 0; + } + } + return undefined; + } + } + function isConstantMemberAccess(node) { + return node.kind === 75 || + node.kind === 194 && isConstantMemberAccess(node.expression) || + node.kind === 195 && isConstantMemberAccess(node.expression) && + ts.isStringLiteralLike(node.argumentExpression); + } + function checkEnumDeclaration(node) { + if (!produceDiagnostics) { + return; + } + checkGrammarDecoratorsAndModifiers(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + checkExportsOnMergedDeclarations(node); + node.members.forEach(checkEnumMember); + computeEnumMemberValues(node); + var enumSymbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind); + if (node === firstDeclaration) { + if (enumSymbol.declarations.length > 1) { + var enumIsConst_1 = ts.isEnumConst(node); + ts.forEach(enumSymbol.declarations, function (decl) { + if (ts.isEnumDeclaration(decl) && ts.isEnumConst(decl) !== enumIsConst_1) { + error(ts.getNameOfDeclaration(decl), ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const); + } + }); + } + var seenEnumMissingInitialInitializer_1 = false; + ts.forEach(enumSymbol.declarations, function (declaration) { + if (declaration.kind !== 248) { + return false; + } + var enumDeclaration = declaration; + if (!enumDeclaration.members.length) { + return false; + } + var firstEnumMember = enumDeclaration.members[0]; + if (!firstEnumMember.initializer) { + if (seenEnumMissingInitialInitializer_1) { + error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element); + } + else { + seenEnumMissingInitialInitializer_1 = true; + } + } + }); + } + } + function checkEnumMember(node) { + if (ts.isPrivateIdentifier(node.name)) { + error(node, ts.Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier); + } + } + function getFirstNonAmbientClassOrFunctionDeclaration(symbol) { + var declarations = symbol.declarations; + for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) { + var declaration = declarations_8[_i]; + if ((declaration.kind === 245 || + (declaration.kind === 244 && ts.nodeIsPresent(declaration.body))) && + !(declaration.flags & 8388608)) { + return declaration; + } + } + return undefined; + } + function inSameLexicalScope(node1, node2) { + var container1 = ts.getEnclosingBlockScopeContainer(node1); + var container2 = ts.getEnclosingBlockScopeContainer(node2); + if (isGlobalSourceFile(container1)) { + return isGlobalSourceFile(container2); + } + else if (isGlobalSourceFile(container2)) { + return false; + } + else { + return container1 === container2; + } + } + function checkModuleDeclaration(node) { + if (produceDiagnostics) { + var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node); + var inAmbientContext = node.flags & 8388608; + if (isGlobalAugmentation && !inAmbientContext) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context); + } + var isAmbientExternalModule = ts.isAmbientModule(node); + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + return; + } + if (!checkGrammarDecoratorsAndModifiers(node)) { + if (!inAmbientContext && node.name.kind === 10) { + grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); + } + } + if (ts.isIdentifier(node.name)) { + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + } + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + if (symbol.flags & 512 + && !inAmbientContext + && symbol.declarations.length > 1 + && isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules)) { + var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); + if (firstNonAmbientClassOrFunc) { + if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) { + error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged); + } + else if (node.pos < firstNonAmbientClassOrFunc.pos) { + error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); + } + } + var mergedClass = ts.getDeclarationOfKind(symbol, 245); + if (mergedClass && + inSameLexicalScope(node, mergedClass)) { + getNodeLinks(node).flags |= 32768; + } + } + if (isAmbientExternalModule) { + if (ts.isExternalModuleAugmentation(node)) { + var checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & 33554432); + if (checkBody && node.body) { + for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + checkModuleAugmentationElement(statement, isGlobalAugmentation); + } + } + } + else if (isGlobalSourceFile(node.parent)) { + if (isGlobalAugmentation) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations); + } + else if (ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(node.name))) { + error(node.name, ts.Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name); + } + } + else { + if (isGlobalAugmentation) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations); + } + else { + error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces); + } + } + } + } + if (node.body) { + checkSourceElement(node.body); + if (!ts.isGlobalScopeAugmentation(node)) { + registerForUnusedIdentifiersCheck(node); + } + } + } + function checkModuleAugmentationElement(node, isGlobalAugmentation) { + switch (node.kind) { + case 225: + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + checkModuleAugmentationElement(decl, isGlobalAugmentation); + } + break; + case 259: + case 260: + grammarErrorOnFirstToken(node, ts.Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations); + break; + case 253: + case 254: + grammarErrorOnFirstToken(node, ts.Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module); + break; + case 191: + case 242: + var name = node.name; + if (ts.isBindingPattern(name)) { + for (var _b = 0, _c = name.elements; _b < _c.length; _b++) { + var el = _c[_b]; + checkModuleAugmentationElement(el, isGlobalAugmentation); + } + break; + } + case 245: + case 248: + case 244: + case 246: + case 249: + case 247: + if (isGlobalAugmentation) { + return; + } + var symbol = getSymbolOfNode(node); + if (symbol) { + var reportError = !(symbol.flags & 33554432); + if (!reportError) { + reportError = !!symbol.parent && ts.isExternalModuleAugmentation(symbol.parent.declarations[0]); + } + } + break; + } + } + function getFirstNonModuleExportsIdentifier(node) { + switch (node.kind) { + case 75: + return node; + case 153: + do { + node = node.left; + } while (node.kind !== 75); + return node; + case 194: + do { + if (ts.isModuleExportsAccessExpression(node.expression) && !ts.isPrivateIdentifier(node.name)) { + return node.name; + } + node = node.expression; + } while (node.kind !== 75); + return node; + } + } + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (!moduleName || ts.nodeIsMissing(moduleName)) { + return false; + } + if (!ts.isStringLiteral(moduleName)) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 250 && ts.isAmbientModule(node.parent.parent); + if (node.parent.kind !== 290 && !inAmbientExternalModule) { + error(moduleName, node.kind === 260 ? + ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : + ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); + return false; + } + if (inAmbientExternalModule && ts.isExternalModuleNameRelative(moduleName.text)) { + if (!isTopLevelInExternalModuleAugmentation(node)) { + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name); + return false; + } + } + return true; + } + function checkAliasSymbol(node) { + var symbol = getSymbolOfNode(node); + var target = resolveAlias(symbol); + var shouldSkipWithJSExpandoTargets = symbol.flags & 67108864; + if (!shouldSkipWithJSExpandoTargets && target !== unknownSymbol) { + symbol = getMergedSymbol(symbol.exportSymbol || symbol); + var excludedMeanings = (symbol.flags & (111551 | 1048576) ? 111551 : 0) | + (symbol.flags & 788968 ? 788968 : 0) | + (symbol.flags & 1920 ? 1920 : 0); + if (target.flags & excludedMeanings) { + var message = node.kind === 263 ? + ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : + ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; + error(node, message, symbolToString(symbol)); + } + if (compilerOptions.isolatedModules + && node.kind === 263 + && !node.parent.parent.isTypeOnly + && !(target.flags & 111551) + && !(node.flags & 8388608)) { + error(node, ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type); + } + } + } + function checkImportBinding(node) { + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name); + checkAliasSymbol(node); + } + function checkImportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause && !checkGrammarImportClause(importClause)) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 256) { + checkImportBinding(importClause.namedBindings); + } + else { + var moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleExisted) { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + } + function checkImportEqualsDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + checkGrammarDecoratorsAndModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); + if (ts.hasModifier(node, 1)) { + markExportAsReferenced(node); + } + if (node.moduleReference.kind !== 265) { + var target = resolveAlias(getSymbolOfNode(node)); + if (target !== unknownSymbol) { + if (target.flags & 111551) { + var moduleName = ts.getFirstIdentifier(node.moduleReference); + if (!(resolveEntityName(moduleName, 111551 | 1920).flags & 1920)) { + error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName)); + } + } + if (target.flags & 788968) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0); + } + } + } + else { + if (moduleKind >= ts.ModuleKind.ES2015 && !(node.flags & 8388608)) { + grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead); + } + } + } + } + function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) { + return; + } + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + checkGrammarExportDeclaration(node); + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause) { + if (ts.isNamedExports(node.exportClause)) { + ts.forEach(node.exportClause.elements, checkExportSpecifier); + } + else if (!ts.isNamespaceExport(node.exportClause)) { + checkImportBinding(node.exportClause); + } + var inAmbientExternalModule = node.parent.kind === 250 && ts.isAmbientModule(node.parent.parent); + var inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 250 && + !node.moduleSpecifier && node.flags & 8388608; + if (node.parent.kind !== 290 && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) { + error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); + } + } + else { + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) { + error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol)); + } + if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) { + checkExternalEmitHelpers(node, 65536); + } + } + } + } + function checkGrammarExportDeclaration(node) { + var _a; + var isTypeOnlyExportStar = node.isTypeOnly && ((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) !== 261; + if (isTypeOnlyExportStar) { + grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type); + } + return !isTypeOnlyExportStar; + } + function checkGrammarModuleElementContext(node, errorMessage) { + var isInAppropriateContext = node.parent.kind === 290 || node.parent.kind === 250 || node.parent.kind === 249; + if (!isInAppropriateContext) { + grammarErrorOnFirstToken(node, errorMessage); + } + return !isInAppropriateContext; + } + function importClauseContainsReferencedImport(importClause) { + return ts.forEachImportClauseDeclaration(importClause, function (declaration) { + return !!getSymbolOfNode(declaration).isReferenced; + }); + } + function importClauseContainsConstEnumUsedAsValue(importClause) { + return ts.forEachImportClauseDeclaration(importClause, function (declaration) { + return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced; + }); + } + function checkImportsForTypeOnlyConversion(sourceFile) { + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (ts.isImportDeclaration(statement) && + statement.importClause && + !statement.importClause.isTypeOnly && + importClauseContainsReferencedImport(statement.importClause) && + !isReferencedAliasDeclaration(statement.importClause, true) && + !importClauseContainsConstEnumUsedAsValue(statement.importClause)) { + error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error); + } + } + } + function checkExportSpecifier(node) { + checkAliasSymbol(node); + if (ts.getEmitDeclarations(compilerOptions)) { + collectLinkedAliases(node.propertyName || node.name, true); + } + if (!node.parent.parent.moduleSpecifier) { + var exportedName = node.propertyName || node.name; + var symbol = resolveName(exportedName, exportedName.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, undefined, true); + if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) { + error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName)); + } + else { + markExportAsReferenced(node); + var target = symbol && (symbol.flags & 2097152 ? resolveAlias(symbol) : symbol); + if (!target || target === unknownSymbol || target.flags & 111551) { + checkExpressionCached(node.propertyName || node.name); + } + } + } + } + function checkExportAssignment(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) { + return; + } + var container = node.parent.kind === 290 ? node.parent : node.parent.parent; + if (container.kind === 249 && !ts.isAmbientModule(container)) { + if (node.isExportEquals) { + error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); + } + else { + error(node, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + } + return; + } + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); + } + if (node.expression.kind === 75) { + var id = node.expression; + var sym = resolveEntityName(id, 67108863, true, true, node); + if (sym) { + markAliasReferenced(sym, id); + var target = sym.flags & 2097152 ? resolveAlias(sym) : sym; + if (target === unknownSymbol || target.flags & 111551) { + checkExpressionCached(node.expression); + } + } + if (ts.getEmitDeclarations(compilerOptions)) { + collectLinkedAliases(node.expression, true); + } + } + else { + checkExpressionCached(node.expression); + } + checkExternalModuleExports(container); + if ((node.flags & 8388608) && !ts.isEntityNameExpression(node.expression)) { + grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context); + } + if (node.isExportEquals && !(node.flags & 8388608)) { + if (moduleKind >= ts.ModuleKind.ES2015) { + grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead); + } + else if (moduleKind === ts.ModuleKind.System) { + grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system); + } + } + } + function hasExportedMembers(moduleSymbol) { + return ts.forEachEntry(moduleSymbol.exports, function (_, id) { return id !== "export="; }); + } + function checkExternalModuleExports(node) { + var moduleSymbol = getSymbolOfNode(node); + var links = getSymbolLinks(moduleSymbol); + if (!links.exportsChecked) { + var exportEqualsSymbol = moduleSymbol.exports.get("export="); + if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) { + var declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration; + if (!isTopLevelInExternalModuleAugmentation(declaration) && !ts.isInJSFile(declaration)) { + error(declaration, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements); + } + } + var exports_2 = getExportsOfModule(moduleSymbol); + if (exports_2) { + exports_2.forEach(function (_a, id) { + var declarations = _a.declarations, flags = _a.flags; + if (id === "__export") { + return; + } + if (flags & (1920 | 64 | 384)) { + return; + } + var exportedDeclarationsCount = ts.countWhere(declarations, isNotOverloadAndNotAccessor); + if (flags & 524288 && exportedDeclarationsCount <= 2) { + return; + } + if (exportedDeclarationsCount > 1) { + for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) { + var declaration = declarations_9[_i]; + if (isNotOverload(declaration)) { + diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Cannot_redeclare_exported_variable_0, ts.unescapeLeadingUnderscores(id))); + } + } + } + }); + } + links.exportsChecked = true; + } + } + function checkSourceElement(node) { + if (node) { + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + checkSourceElementWorker(node); + currentNode = saveCurrentNode; + } + } + function checkSourceElementWorker(node) { + if (ts.isInJSFile(node)) { + ts.forEach(node.jsDoc, function (_a) { + var tags = _a.tags; + return ts.forEach(tags, checkSourceElement); + }); + } + var kind = node.kind; + if (cancellationToken) { + switch (kind) { + case 249: + case 245: + case 246: + case 244: + cancellationToken.throwIfCancellationRequested(); + } + } + if (kind >= 225 && kind <= 241 && node.flowNode && !isReachableFlowNode(node.flowNode)) { + errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, ts.Diagnostics.Unreachable_code_detected); + } + switch (kind) { + case 155: + return checkTypeParameter(node); + case 156: + return checkParameter(node); + case 159: + return checkPropertyDeclaration(node); + case 158: + return checkPropertySignature(node); + case 170: + case 171: + case 165: + case 166: + case 167: + return checkSignatureDeclaration(node); + case 161: + case 160: + return checkMethodDeclaration(node); + case 162: + return checkConstructorDeclaration(node); + case 163: + case 164: + return checkAccessorDeclaration(node); + case 169: + return checkTypeReferenceNode(node); + case 168: + return checkTypePredicate(node); + case 172: + return checkTypeQuery(node); + case 173: + return checkTypeLiteral(node); + case 174: + return checkArrayType(node); + case 175: + return checkTupleType(node); + case 178: + case 179: + return checkUnionOrIntersectionType(node); + case 182: + case 176: + case 177: + return checkSourceElement(node.type); + case 183: + return checkThisType(node); + case 184: + return checkTypeOperator(node); + case 180: + return checkConditionalType(node); + case 181: + return checkInferType(node); + case 188: + return checkImportType(node); + case 307: + return checkJSDocAugmentsTag(node); + case 321: + case 314: + case 315: + return checkJSDocTypeAliasTag(node); + case 320: + return checkJSDocTemplateTag(node); + case 319: + return checkJSDocTypeTag(node); + case 316: + return checkJSDocParameterTag(node); + case 300: + checkJSDocFunctionType(node); + case 298: + case 297: + case 295: + case 296: + case 304: + checkJSDocTypeIsInJsFile(node); + ts.forEachChild(node, checkSourceElement); + return; + case 301: + checkJSDocVariadicType(node); + return; + case 294: + return checkSourceElement(node.type); + case 185: + return checkIndexedAccessType(node); + case 186: + return checkMappedType(node); + case 244: + return checkFunctionDeclaration(node); + case 223: + case 250: + return checkBlock(node); + case 225: + return checkVariableStatement(node); + case 226: + return checkExpressionStatement(node); + case 227: + return checkIfStatement(node); + case 228: + return checkDoStatement(node); + case 229: + return checkWhileStatement(node); + case 230: + return checkForStatement(node); + case 231: + return checkForInStatement(node); + case 232: + return checkForOfStatement(node); + case 233: + case 234: + return checkBreakOrContinueStatement(node); + case 235: + return checkReturnStatement(node); + case 236: + return checkWithStatement(node); + case 237: + return checkSwitchStatement(node); + case 238: + return checkLabeledStatement(node); + case 239: + return checkThrowStatement(node); + case 240: + return checkTryStatement(node); + case 242: + return checkVariableDeclaration(node); + case 191: + return checkBindingElement(node); + case 245: + return checkClassDeclaration(node); + case 246: + return checkInterfaceDeclaration(node); + case 247: + return checkTypeAliasDeclaration(node); + case 248: + return checkEnumDeclaration(node); + case 249: + return checkModuleDeclaration(node); + case 254: + return checkImportDeclaration(node); + case 253: + return checkImportEqualsDeclaration(node); + case 260: + return checkExportDeclaration(node); + case 259: + return checkExportAssignment(node); + case 224: + case 241: + checkGrammarStatementInAmbientContext(node); + return; + case 264: + return checkMissingDeclaration(node); + } + } + function checkJSDocTypeIsInJsFile(node) { + if (!ts.isInJSFile(node)) { + grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + } + function checkJSDocVariadicType(node) { + checkJSDocTypeIsInJsFile(node); + checkSourceElement(node.type); + var parent = node.parent; + if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) { + if (ts.last(parent.parent.parameters) !== parent) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + return; + } + if (!ts.isJSDocTypeExpression(parent)) { + error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + } + var paramTag = node.parent.parent; + if (!ts.isJSDocParameterTag(paramTag)) { + error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + return; + } + var param = ts.getParameterSymbolFromJSDoc(paramTag); + if (!param) { + return; + } + var host = ts.getHostSignatureFromJSDoc(paramTag); + if (!host || ts.last(host.parameters).symbol !== param) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + } + function getTypeFromJSDocVariadicType(node) { + var type = getTypeFromTypeNode(node.type); + var parent = node.parent; + var paramTag = node.parent.parent; + if (ts.isJSDocTypeExpression(node.parent) && ts.isJSDocParameterTag(paramTag)) { + var host_1 = ts.getHostSignatureFromJSDoc(paramTag); + if (host_1) { + var lastParamDeclaration = ts.lastOrUndefined(host_1.parameters); + var symbol = ts.getParameterSymbolFromJSDoc(paramTag); + if (!lastParamDeclaration || + symbol && lastParamDeclaration.symbol === symbol && ts.isRestParameter(lastParamDeclaration)) { + return createArrayType(type); + } + } + } + if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) { + return createArrayType(type); + } + return addOptionality(type); + } + function checkNodeDeferred(node) { + var enclosingFile = ts.getSourceFileOfNode(node); + var links = getNodeLinks(enclosingFile); + if (!(links.flags & 1)) { + links.deferredNodes = links.deferredNodes || ts.createMap(); + var id = "" + getNodeId(node); + links.deferredNodes.set(id, node); + } + } + function checkDeferredNodes(context) { + var links = getNodeLinks(context); + if (links.deferredNodes) { + links.deferredNodes.forEach(checkDeferredNode); + } + } + function checkDeferredNode(node) { + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + switch (node.kind) { + case 201: + case 202: + case 161: + case 160: + checkFunctionExpressionOrObjectLiteralMethodDeferred(node); + break; + case 163: + case 164: + checkAccessorDeclaration(node); + break; + case 214: + checkClassExpressionDeferred(node); + break; + case 267: + checkJsxSelfClosingElementDeferred(node); + break; + case 266: + checkJsxElementDeferred(node); + break; + } + currentNode = saveCurrentNode; + } + function checkSourceFile(node) { + ts.performance.mark("beforeCheck"); + checkSourceFileWorker(node); + ts.performance.mark("afterCheck"); + ts.performance.measure("Check", "beforeCheck", "afterCheck"); + } + function unusedIsError(kind, isAmbient) { + if (isAmbient) { + return false; + } + switch (kind) { + case 0: + return !!compilerOptions.noUnusedLocals; + case 1: + return !!compilerOptions.noUnusedParameters; + default: + return ts.Debug.assertNever(kind); + } + } + function getPotentiallyUnusedIdentifiers(sourceFile) { + return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || ts.emptyArray; + } + function checkSourceFileWorker(node) { + var links = getNodeLinks(node); + if (!(links.flags & 1)) { + if (ts.skipTypeChecking(node, compilerOptions, host)) { + return; + } + checkGrammarSourceFile(node); + ts.clear(potentialThisCollisions); + ts.clear(potentialNewTargetCollisions); + ts.clear(potentialWeakMapCollisions); + ts.forEach(node.statements, checkSourceElement); + checkSourceElement(node.endOfFileToken); + checkDeferredNodes(node); + if (ts.isExternalOrCommonJsModule(node)) { + registerForUnusedIdentifiersCheck(node); + } + if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) { + checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) { + if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608))) { + diagnostics.add(diag); + } + }); + } + if (compilerOptions.importsNotUsedAsValues === 2 && + !node.isDeclarationFile && + ts.isExternalModule(node)) { + checkImportsForTypeOnlyConversion(node); + } + if (ts.isExternalOrCommonJsModule(node)) { + checkExternalModuleExports(node); + } + if (potentialThisCollisions.length) { + ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); + ts.clear(potentialThisCollisions); + } + if (potentialNewTargetCollisions.length) { + ts.forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope); + ts.clear(potentialNewTargetCollisions); + } + if (potentialWeakMapCollisions.length) { + ts.forEach(potentialWeakMapCollisions, checkWeakMapCollision); + ts.clear(potentialWeakMapCollisions); + } + links.flags |= 1; + } + } + function getDiagnostics(sourceFile, ct) { + try { + cancellationToken = ct; + return getDiagnosticsWorker(sourceFile); + } + finally { + cancellationToken = undefined; + } + } + function getDiagnosticsWorker(sourceFile) { + throwIfNonDiagnosticsProducing(); + if (sourceFile) { + var previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics(); + var previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length; + checkSourceFile(sourceFile); + var semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName); + var currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics(); + if (currentGlobalDiagnostics !== previousGlobalDiagnostics) { + var deferredGlobalDiagnostics = ts.relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, ts.compareDiagnostics); + return ts.concatenate(deferredGlobalDiagnostics, semanticDiagnostics); + } + else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) { + return ts.concatenate(currentGlobalDiagnostics, semanticDiagnostics); + } + return semanticDiagnostics; + } + ts.forEach(host.getSourceFiles(), checkSourceFile); + return diagnostics.getDiagnostics(); + } + function getGlobalDiagnostics() { + throwIfNonDiagnosticsProducing(); + return diagnostics.getGlobalDiagnostics(); + } + function throwIfNonDiagnosticsProducing() { + if (!produceDiagnostics) { + throw new Error("Trying to get diagnostics from a type checker that does not produce them."); + } + } + function getSymbolsInScope(location, meaning) { + if (location.flags & 16777216) { + return []; + } + var symbols = ts.createSymbolTable(); + var isStatic = false; + populateSymbols(); + symbols.delete("this"); + return symbolsToArray(symbols); + function populateSymbols() { + while (location) { + if (location.locals && !isGlobalSourceFile(location)) { + copySymbols(location.locals, meaning); + } + switch (location.kind) { + case 290: + if (!ts.isExternalOrCommonJsModule(location)) + break; + case 249: + copySymbols(getSymbolOfNode(location).exports, meaning & 2623475); + break; + case 248: + copySymbols(getSymbolOfNode(location).exports, meaning & 8); + break; + case 214: + var className = location.name; + if (className) { + copySymbol(location.symbol, meaning); + } + case 245: + case 246: + if (!isStatic) { + copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & 788968); + } + break; + case 201: + var funcName = location.name; + if (funcName) { + copySymbol(location.symbol, meaning); + } + break; + } + if (ts.introducesArgumentsExoticObject(location)) { + copySymbol(argumentsSymbol, meaning); + } + isStatic = ts.hasModifier(location, 32); + location = location.parent; + } + copySymbols(globals, meaning); + } + function copySymbol(symbol, meaning) { + if (ts.getCombinedLocalAndExportSymbolFlags(symbol) & meaning) { + var id = symbol.escapedName; + if (!symbols.has(id)) { + symbols.set(id, symbol); + } + } + } + function copySymbols(source, meaning) { + if (meaning) { + source.forEach(function (symbol) { + copySymbol(symbol, meaning); + }); + } + } + } + function isTypeDeclarationName(name) { + return name.kind === 75 && + isTypeDeclaration(name.parent) && + name.parent.name === name; + } + function isTypeDeclaration(node) { + switch (node.kind) { + case 155: + case 245: + case 246: + case 247: + case 248: + return true; + case 255: + return node.isTypeOnly; + case 258: + case 263: + return node.parent.parent.isTypeOnly; + default: + return false; + } + } + function isTypeReferenceIdentifier(node) { + while (node.parent.kind === 153) { + node = node.parent; + } + return node.parent.kind === 169; + } + function isHeritageClauseElementIdentifier(node) { + while (node.parent.kind === 194) { + node = node.parent; + } + return node.parent.kind === 216; + } + function forEachEnclosingClass(node, callback) { + var result; + while (true) { + node = ts.getContainingClass(node); + if (!node) + break; + if (result = callback(node)) + break; + } + return result; + } + function isNodeUsedDuringClassInitialization(node) { + return !!ts.findAncestor(node, function (element) { + if (ts.isConstructorDeclaration(element) && ts.nodeIsPresent(element.body) || ts.isPropertyDeclaration(element)) { + return true; + } + else if (ts.isClassLike(element) || ts.isFunctionLikeDeclaration(element)) { + return "quit"; + } + return false; + }); + } + function isNodeWithinClass(node, classDeclaration) { + return !!forEachEnclosingClass(node, function (n) { return n === classDeclaration; }); + } + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 153) { + nodeOnRightSide = nodeOnRightSide.parent; + } + if (nodeOnRightSide.parent.kind === 253) { + return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : undefined; + } + if (nodeOnRightSide.parent.kind === 259) { + return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : undefined; + } + return undefined; + } + function isInRightSideOfImportOrExportAssignment(node) { + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; + } + function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) { + var specialPropertyAssignmentKind = ts.getAssignmentDeclarationKind(entityName.parent.parent); + switch (specialPropertyAssignmentKind) { + case 1: + case 3: + return getSymbolOfNode(entityName.parent); + case 4: + case 2: + case 5: + return getSymbolOfNode(entityName.parent.parent); + } + } + function isImportTypeQualifierPart(node) { + var parent = node.parent; + while (ts.isQualifiedName(parent)) { + node = parent; + parent = parent.parent; + } + if (parent && parent.kind === 188 && parent.qualifier === node) { + return parent; + } + return undefined; + } + function getSymbolOfNameOrPropertyAccessExpression(name) { + if (ts.isDeclarationName(name)) { + return getSymbolOfNode(name.parent); + } + if (ts.isInJSFile(name) && + name.parent.kind === 194 && + name.parent === name.parent.parent.left) { + if (!ts.isPrivateIdentifier(name)) { + var specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name); + if (specialPropertyAssignmentSymbol) { + return specialPropertyAssignmentSymbol; + } + } + } + if (name.parent.kind === 259 && ts.isEntityNameExpression(name)) { + var success = resolveEntityName(name, 111551 | 788968 | 1920 | 2097152, true); + if (success && success !== unknownSymbol) { + return success; + } + } + else if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name) && isInRightSideOfImportOrExportAssignment(name)) { + var importEqualsDeclaration = ts.getAncestor(name, 253); + ts.Debug.assert(importEqualsDeclaration !== undefined); + return getSymbolOfPartOfRightHandSideOfImportEquals(name, true); + } + if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name)) { + var possibleImportNode = isImportTypeQualifierPart(name); + if (possibleImportNode) { + getTypeFromTypeNode(possibleImportNode); + var sym = getNodeLinks(name).resolvedSymbol; + return sym === unknownSymbol ? undefined : sym; + } + } + while (ts.isRightSideOfQualifiedNameOrPropertyAccess(name)) { + name = name.parent; + } + if (isHeritageClauseElementIdentifier(name)) { + var meaning = 0; + if (name.parent.kind === 216) { + meaning = 788968; + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) { + meaning |= 111551; + } + } + else { + meaning = 1920; + } + meaning |= 2097152; + var entityNameSymbol = ts.isEntityNameExpression(name) ? resolveEntityName(name, meaning) : undefined; + if (entityNameSymbol) { + return entityNameSymbol; + } + } + if (name.parent.kind === 316) { + return ts.getParameterSymbolFromJSDoc(name.parent); + } + if (name.parent.kind === 155 && name.parent.parent.kind === 320) { + ts.Debug.assert(!ts.isInJSFile(name)); + var typeParameter = ts.getTypeParameterFromJsDoc(name.parent); + return typeParameter && typeParameter.symbol; + } + if (ts.isExpressionNode(name)) { + if (ts.nodeIsMissing(name)) { + return undefined; + } + if (name.kind === 75) { + if (ts.isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) { + var symbol = getIntrinsicTagSymbol(name.parent); + return symbol === unknownSymbol ? undefined : symbol; + } + return resolveEntityName(name, 111551, false, true); + } + else if (name.kind === 194 || name.kind === 153) { + var links = getNodeLinks(name); + if (links.resolvedSymbol) { + return links.resolvedSymbol; + } + if (name.kind === 194) { + checkPropertyAccessExpression(name); + } + else { + checkQualifiedName(name); + } + return links.resolvedSymbol; + } + } + else if (isTypeReferenceIdentifier(name)) { + var meaning = name.parent.kind === 169 ? 788968 : 1920; + return resolveEntityName(name, meaning, false, true); + } + if (name.parent.kind === 168) { + return resolveEntityName(name, 1); + } + return undefined; + } + function getSymbolAtLocation(node) { + if (node.kind === 290) { + return ts.isExternalModule(node) ? getMergedSymbol(node.symbol) : undefined; + } + var parent = node.parent; + var grandParent = parent.parent; + if (node.flags & 16777216) { + return undefined; + } + if (isDeclarationNameOrImportPropertyName(node)) { + var parentSymbol = getSymbolOfNode(parent); + return ts.isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node + ? getImmediateAliasedSymbol(parentSymbol) + : parentSymbol; + } + else if (ts.isLiteralComputedPropertyDeclarationName(node)) { + return getSymbolOfNode(parent.parent); + } + if (node.kind === 75) { + if (isInRightSideOfImportOrExportAssignment(node)) { + return getSymbolOfNameOrPropertyAccessExpression(node); + } + else if (parent.kind === 191 && + grandParent.kind === 189 && + node === parent.propertyName) { + var typeOfPattern = getTypeOfNode(grandParent); + var propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText); + if (propertyDeclaration) { + return propertyDeclaration; + } + } + } + switch (node.kind) { + case 75: + case 76: + case 194: + case 153: + return getSymbolOfNameOrPropertyAccessExpression(node); + case 104: + var container = ts.getThisContainer(node, false); + if (ts.isFunctionLike(container)) { + var sig = getSignatureFromDeclaration(container); + if (sig.thisParameter) { + return sig.thisParameter; + } + } + if (ts.isInExpressionContext(node)) { + return checkExpression(node).symbol; + } + case 183: + return getTypeFromThisTypeNode(node).symbol; + case 102: + return checkExpression(node).symbol; + case 129: + var constructorDeclaration = node.parent; + if (constructorDeclaration && constructorDeclaration.kind === 162) { + return constructorDeclaration.parent.symbol; + } + return undefined; + case 10: + case 14: + if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || + ((node.parent.kind === 254 || node.parent.kind === 260) && node.parent.moduleSpecifier === node) || + ((ts.isInJSFile(node) && ts.isRequireCall(node.parent, false)) || ts.isImportCall(node.parent)) || + (ts.isLiteralTypeNode(node.parent) && ts.isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent)) { + return resolveExternalModuleName(node, node); + } + if (ts.isCallExpression(parent) && ts.isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) { + return getSymbolOfNode(parent); + } + case 8: + var objectType = ts.isElementAccessExpression(parent) + ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : undefined + : ts.isLiteralTypeNode(parent) && ts.isIndexedAccessTypeNode(grandParent) + ? getTypeFromTypeNode(grandParent.objectType) + : undefined; + return objectType && getPropertyOfType(objectType, ts.escapeLeadingUnderscores(node.text)); + case 84: + case 94: + case 38: + case 80: + return getSymbolOfNode(node.parent); + case 188: + return ts.isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal) : undefined; + case 89: + return ts.isExportAssignment(node.parent) ? ts.Debug.assertDefined(node.parent.symbol) : undefined; + default: + return undefined; + } + } + function getShorthandAssignmentValueSymbol(location) { + if (location && location.kind === 282) { + return resolveEntityName(location.name, 111551 | 2097152); + } + return undefined; + } + function getExportSpecifierLocalTargetSymbol(node) { + return node.parent.parent.moduleSpecifier ? + getExternalModuleMember(node.parent.parent, node) : + resolveEntityName(node.propertyName || node.name, 111551 | 788968 | 1920 | 2097152); + } + function getTypeOfNode(node) { + if (node.flags & 16777216) { + return errorType; + } + var classDecl = ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node); + var classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class)); + if (ts.isPartOfTypeNode(node)) { + var typeFromTypeNode = getTypeFromTypeNode(node); + return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode; + } + if (ts.isExpressionNode(node)) { + return getRegularTypeOfExpression(node); + } + if (classType && !classDecl.isImplements) { + var baseType = ts.firstOrUndefined(getBaseTypes(classType)); + return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType; + } + if (isTypeDeclaration(node)) { + var symbol = getSymbolOfNode(node); + return getDeclaredTypeOfSymbol(symbol); + } + if (isTypeDeclarationName(node)) { + var symbol = getSymbolAtLocation(node); + return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType; + } + if (ts.isDeclaration(node)) { + var symbol = getSymbolOfNode(node); + return getTypeOfSymbol(symbol); + } + if (isDeclarationNameOrImportPropertyName(node)) { + var symbol = getSymbolAtLocation(node); + if (symbol) { + return getTypeOfSymbol(symbol); + } + return errorType; + } + if (ts.isBindingPattern(node)) { + return getTypeForVariableLikeDeclaration(node.parent, true) || errorType; + } + if (isInRightSideOfImportOrExportAssignment(node)) { + var symbol = getSymbolAtLocation(node); + if (symbol) { + var declaredType = getDeclaredTypeOfSymbol(symbol); + return declaredType !== errorType ? declaredType : getTypeOfSymbol(symbol); + } + } + return errorType; + } + function getTypeOfAssignmentPattern(expr) { + ts.Debug.assert(expr.kind === 193 || expr.kind === 192); + if (expr.parent.kind === 232) { + var iteratedType = checkRightHandSideOfForOf(expr.parent.expression, expr.parent.awaitModifier); + return checkDestructuringAssignment(expr, iteratedType || errorType); + } + if (expr.parent.kind === 209) { + var iteratedType = getTypeOfExpression(expr.parent.right); + return checkDestructuringAssignment(expr, iteratedType || errorType); + } + if (expr.parent.kind === 281) { + var node_4 = ts.cast(expr.parent.parent, ts.isObjectLiteralExpression); + var typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node_4) || errorType; + var propertyIndex = ts.indexOfNode(node_4.properties, expr.parent); + return checkObjectLiteralDestructuringPropertyAssignment(node_4, typeOfParentObjectLiteral, propertyIndex); + } + var node = ts.cast(expr.parent, ts.isArrayLiteralExpression); + var typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType; + var elementType = checkIteratedTypeOrElementType(65, typeOfArrayLiteral, undefinedType, expr.parent) || errorType; + return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType); + } + function getPropertySymbolOfDestructuringAssignment(location) { + var typeOfObjectLiteral = getTypeOfAssignmentPattern(ts.cast(location.parent.parent, ts.isAssignmentPattern)); + return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.escapedText); + } + function getRegularTypeOfExpression(expr) { + if (ts.isRightSideOfQualifiedNameOrPropertyAccess(expr)) { + expr = expr.parent; + } + return getRegularTypeOfLiteralType(getTypeOfExpression(expr)); + } + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return ts.hasModifier(node, 32) + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } + function getClassElementPropertyKeyType(element) { + var name = element.name; + switch (name.kind) { + case 75: + return getLiteralType(ts.idText(name)); + case 8: + case 10: + return getLiteralType(name.text); + case 154: + var nameType = checkComputedPropertyName(name); + return isTypeAssignableToKind(nameType, 12288) ? nameType : stringType; + default: + return ts.Debug.fail("Unsupported property name."); + } + } + function getAugmentedPropertiesOfType(type) { + type = getApparentType(type); + var propsByName = ts.createSymbolTable(getPropertiesOfType(type)); + var functionType = getSignaturesOfType(type, 0).length ? globalCallableFunctionType : + getSignaturesOfType(type, 1).length ? globalNewableFunctionType : + undefined; + if (functionType) { + ts.forEach(getPropertiesOfType(functionType), function (p) { + if (!propsByName.has(p.escapedName)) { + propsByName.set(p.escapedName, p); + } + }); + } + return getNamedMembers(propsByName); + } + function typeHasCallOrConstructSignatures(type) { + return ts.typeHasCallOrConstructSignatures(type, checker); + } + function getRootSymbols(symbol) { + var roots = getImmediateRootSymbols(symbol); + return roots ? ts.flatMap(roots, getRootSymbols) : [symbol]; + } + function getImmediateRootSymbols(symbol) { + if (ts.getCheckFlags(symbol) & 6) { + return ts.mapDefined(getSymbolLinks(symbol).containingType.types, function (type) { return getPropertyOfType(type, symbol.escapedName); }); + } + else if (symbol.flags & 33554432) { + var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin; + return leftSpread ? [leftSpread, rightSpread] + : syntheticOrigin ? [syntheticOrigin] + : ts.singleElementArray(tryGetAliasTarget(symbol)); + } + return undefined; + } + function tryGetAliasTarget(symbol) { + var target; + var next = symbol; + while (next = getSymbolLinks(next).target) { + target = next; + } + return target; + } + function isArgumentsLocalBinding(nodeIn) { + if (!ts.isGeneratedIdentifier(nodeIn)) { + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var isPropertyName_1 = node.parent.kind === 194 && node.parent.name === node; + return !isPropertyName_1 && getReferencedValueSymbol(node) === argumentsSymbol; + } + } + return false; + } + function moduleExportsSomeValue(moduleReferenceExpression) { + var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression); + if (!moduleSymbol || ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + return true; + } + var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol); + moduleSymbol = resolveExternalModuleSymbol(moduleSymbol); + var symbolLinks = getSymbolLinks(moduleSymbol); + if (symbolLinks.exportsSomeValue === undefined) { + symbolLinks.exportsSomeValue = hasExportAssignment + ? !!(moduleSymbol.flags & 111551) + : ts.forEachEntry(getExportsOfModule(moduleSymbol), isValue); + } + return symbolLinks.exportsSomeValue; + function isValue(s) { + s = resolveSymbol(s); + return s && !!(s.flags & 111551); + } + } + function isNameOfModuleOrEnumDeclaration(node) { + return ts.isModuleOrEnumDeclaration(node.parent) && node === node.parent.name; + } + function getReferencedExportContainer(nodeIn, prefixLocals) { + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var symbol = getReferencedValueSymbol(node, isNameOfModuleOrEnumDeclaration(node)); + if (symbol) { + if (symbol.flags & 1048576) { + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (!prefixLocals && exportSymbol.flags & 944 && !(exportSymbol.flags & 3)) { + return undefined; + } + symbol = exportSymbol; + } + var parentSymbol_1 = getParentOfSymbol(symbol); + if (parentSymbol_1) { + if (parentSymbol_1.flags & 512 && parentSymbol_1.valueDeclaration.kind === 290) { + var symbolFile = parentSymbol_1.valueDeclaration; + var referenceFile = ts.getSourceFileOfNode(node); + var symbolIsUmdExport = symbolFile !== referenceFile; + return symbolIsUmdExport ? undefined : symbolFile; + } + return ts.findAncestor(node.parent, function (n) { return ts.isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol_1; }); + } + } + } + } + function getReferencedImportDeclaration(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var symbol = getReferencedValueSymbol(node); + if (isNonLocalAlias(symbol, 111551) && !getTypeOnlyAliasDeclaration(symbol)) { + return getDeclarationOfAliasSymbol(symbol); + } + } + return undefined; + } + function isSymbolOfDestructuredElementOfCatchBinding(symbol) { + return ts.isBindingElement(symbol.valueDeclaration) + && ts.walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 280; + } + function isSymbolOfDeclarationWithCollidingName(symbol) { + if (symbol.flags & 418 && !ts.isSourceFile(symbol.valueDeclaration)) { + var links = getSymbolLinks(symbol); + if (links.isDeclarationWithCollidingName === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + if (ts.isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) { + var nodeLinks_1 = getNodeLinks(symbol.valueDeclaration); + if (resolveName(container.parent, symbol.escapedName, 111551, undefined, undefined, false)) { + links.isDeclarationWithCollidingName = true; + } + else if (nodeLinks_1.flags & 262144) { + var isDeclaredInLoop = nodeLinks_1.flags & 524288; + var inLoopInitializer = ts.isIterationStatement(container, false); + var inLoopBodyBlock = container.kind === 223 && ts.isIterationStatement(container.parent, false); + links.isDeclarationWithCollidingName = !ts.isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || (!inLoopInitializer && !inLoopBodyBlock)); + } + else { + links.isDeclarationWithCollidingName = false; + } + } + } + return links.isDeclarationWithCollidingName; + } + return false; + } + function getReferencedDeclarationWithCollidingName(nodeIn) { + if (!ts.isGeneratedIdentifier(nodeIn)) { + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var symbol = getReferencedValueSymbol(node); + if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) { + return symbol.valueDeclaration; + } + } + } + return undefined; + } + function isDeclarationWithCollidingName(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration); + if (node) { + var symbol = getSymbolOfNode(node); + if (symbol) { + return isSymbolOfDeclarationWithCollidingName(symbol); + } + } + return false; + } + function isValueAliasDeclaration(node) { + switch (node.kind) { + case 253: + return isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol); + case 255: + case 256: + case 258: + case 263: + var symbol = getSymbolOfNode(node) || unknownSymbol; + return isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol); + case 260: + var exportClause = node.exportClause; + return !!exportClause && (ts.isNamespaceExport(exportClause) || + ts.some(exportClause.elements, isValueAliasDeclaration)); + case 259: + return node.expression && node.expression.kind === 75 ? + isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol) : + true; + } + return false; + } + function isTopLevelValueImportEqualsWithEntityName(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isImportEqualsDeclaration); + if (node === undefined || node.parent.kind !== 290 || !ts.isInternalModuleImportEqualsDeclaration(node)) { + return false; + } + var isValue = isAliasResolvedToValue(getSymbolOfNode(node)); + return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference); + } + function isAliasResolvedToValue(symbol) { + var target = resolveAlias(symbol); + if (target === unknownSymbol) { + return true; + } + return !!(target.flags & 111551) && + (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target)); + } + function isConstEnumOrConstEnumOnlyModule(s) { + return isConstEnumSymbol(s) || !!s.constEnumOnlyModule; + } + function isReferencedAliasDeclaration(node, checkChildren) { + if (isAliasSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + if (symbol && getSymbolLinks(symbol).referenced) { + return true; + } + var target = getSymbolLinks(symbol).target; + if (target && ts.getModifierFlags(node) & 1 && + target.flags & 111551 && + (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target))) { + return true; + } + } + if (checkChildren) { + return !!ts.forEachChild(node, function (node) { return isReferencedAliasDeclaration(node, checkChildren); }); + } + return false; + } + function isImplementationOfOverload(node) { + if (ts.nodeIsPresent(node.body)) { + if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) + return false; + var symbol = getSymbolOfNode(node); + var signaturesOfSymbol = getSignaturesOfSymbol(symbol); + return signaturesOfSymbol.length > 1 || + (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node); + } + return false; + } + function isRequiredInitializedParameter(parameter) { + return !!strictNullChecks && + !isOptionalParameter(parameter) && + !ts.isJSDocParameterTag(parameter) && + !!parameter.initializer && + !ts.hasModifier(parameter, 92); + } + function isOptionalUninitializedParameterProperty(parameter) { + return strictNullChecks && + isOptionalParameter(parameter) && + !parameter.initializer && + ts.hasModifier(parameter, 92); + } + function isExpandoFunctionDeclaration(node) { + var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration); + if (!declaration) { + return false; + } + var symbol = getSymbolOfNode(declaration); + if (!symbol || !(symbol.flags & 16)) { + return false; + } + return !!ts.forEachEntry(getExportsOfSymbol(symbol), function (p) { return p.flags & 111551 && p.valueDeclaration && ts.isPropertyAccessExpression(p.valueDeclaration); }); + } + function getPropertiesOfContainerFunction(node) { + var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration); + if (!declaration) { + return ts.emptyArray; + } + var symbol = getSymbolOfNode(declaration); + return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || ts.emptyArray; + } + function getNodeCheckFlags(node) { + return getNodeLinks(node).flags || 0; + } + function getEnumMemberValue(node) { + computeEnumMemberValues(node.parent); + return getNodeLinks(node).enumMemberValue; + } + function canHaveConstantValue(node) { + switch (node.kind) { + case 284: + case 194: + case 195: + return true; + } + return false; + } + function getConstantValue(node) { + if (node.kind === 284) { + return getEnumMemberValue(node); + } + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol && (symbol.flags & 8)) { + var member = symbol.valueDeclaration; + if (ts.isEnumConst(member.parent)) { + return getEnumMemberValue(member); + } + } + return undefined; + } + function isFunctionType(type) { + return !!(type.flags & 524288) && getSignaturesOfType(type, 0).length > 0; + } + function getTypeReferenceSerializationKind(typeNameIn, location) { + var typeName = ts.getParseTreeNode(typeNameIn, ts.isEntityName); + if (!typeName) + return ts.TypeReferenceSerializationKind.Unknown; + if (location) { + location = ts.getParseTreeNode(location); + if (!location) + return ts.TypeReferenceSerializationKind.Unknown; + } + var valueSymbol = resolveEntityName(typeName, 111551, true, false, location); + var typeSymbol = resolveEntityName(typeName, 788968, true, false, location); + if (valueSymbol && valueSymbol === typeSymbol) { + var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false); + if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) { + return ts.TypeReferenceSerializationKind.Promise; + } + var constructorType = getTypeOfSymbol(valueSymbol); + if (constructorType && isConstructorType(constructorType)) { + return ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue; + } + } + if (!typeSymbol) { + return ts.TypeReferenceSerializationKind.Unknown; + } + var type = getDeclaredTypeOfSymbol(typeSymbol); + if (type === errorType) { + return ts.TypeReferenceSerializationKind.Unknown; + } + else if (type.flags & 3) { + return ts.TypeReferenceSerializationKind.ObjectType; + } + else if (isTypeAssignableToKind(type, 16384 | 98304 | 131072)) { + return ts.TypeReferenceSerializationKind.VoidNullableOrNeverType; + } + else if (isTypeAssignableToKind(type, 528)) { + return ts.TypeReferenceSerializationKind.BooleanType; + } + else if (isTypeAssignableToKind(type, 296)) { + return ts.TypeReferenceSerializationKind.NumberLikeType; + } + else if (isTypeAssignableToKind(type, 2112)) { + return ts.TypeReferenceSerializationKind.BigIntLikeType; + } + else if (isTypeAssignableToKind(type, 132)) { + return ts.TypeReferenceSerializationKind.StringLikeType; + } + else if (isTupleType(type)) { + return ts.TypeReferenceSerializationKind.ArrayLikeType; + } + else if (isTypeAssignableToKind(type, 12288)) { + return ts.TypeReferenceSerializationKind.ESSymbolType; + } + else if (isFunctionType(type)) { + return ts.TypeReferenceSerializationKind.TypeWithCallSignature; + } + else if (isArrayType(type)) { + return ts.TypeReferenceSerializationKind.ArrayLikeType; + } + else { + return ts.TypeReferenceSerializationKind.ObjectType; + } + } + function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) { + var declaration = ts.getParseTreeNode(declarationIn, ts.isVariableLikeOrAccessor); + if (!declaration) { + return ts.createToken(125); + } + var symbol = getSymbolOfNode(declaration); + var type = symbol && !(symbol.flags & (2048 | 131072)) + ? getWidenedLiteralType(getTypeOfSymbol(symbol)) + : errorType; + if (type.flags & 8192 && + type.symbol === symbol) { + flags |= 1048576; + } + if (addUndefined) { + type = getOptionalType(type); + } + return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker); + } + function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) { + var signatureDeclaration = ts.getParseTreeNode(signatureDeclarationIn, ts.isFunctionLike); + if (!signatureDeclaration) { + return ts.createToken(125); + } + var signature = getSignatureFromDeclaration(signatureDeclaration); + return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024, tracker); + } + function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) { + var expr = ts.getParseTreeNode(exprIn, ts.isExpression); + if (!expr) { + return ts.createToken(125); + } + var type = getWidenedType(getRegularTypeOfExpression(expr)); + return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker); + } + function hasGlobalName(name) { + return globals.has(ts.escapeLeadingUnderscores(name)); + } + function getReferencedValueSymbol(reference, startInDeclarationContainer) { + var resolvedSymbol = getNodeLinks(reference).resolvedSymbol; + if (resolvedSymbol) { + return resolvedSymbol; + } + var location = reference; + if (startInDeclarationContainer) { + var parent = reference.parent; + if (ts.isDeclaration(parent) && reference === parent.name) { + location = getDeclarationContainer(parent); + } + } + return resolveName(location, reference.escapedText, 111551 | 1048576 | 2097152, undefined, undefined, true); + } + function getReferencedValueDeclaration(referenceIn) { + if (!ts.isGeneratedIdentifier(referenceIn)) { + var reference = ts.getParseTreeNode(referenceIn, ts.isIdentifier); + if (reference) { + var symbol = getReferencedValueSymbol(reference); + if (symbol) { + return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; + } + } + } + return undefined; + } + function isLiteralConstDeclaration(node) { + if (ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) { + return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node))); + } + return false; + } + function literalTypeToNode(type, enclosing, tracker) { + var enumResult = type.flags & 1024 ? nodeBuilder.symbolToExpression(type.symbol, 111551, enclosing, undefined, tracker) + : type === trueType ? ts.createTrue() : type === falseType && ts.createFalse(); + return enumResult || ts.createLiteral(type.value); + } + function createLiteralConstValue(node, tracker) { + var type = getTypeOfSymbol(getSymbolOfNode(node)); + return literalTypeToNode(type, node, tracker); + } + function createResolver() { + var resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives(); + var fileToDirective; + if (resolvedTypeReferenceDirectives) { + fileToDirective = ts.createMap(); + resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key) { + if (!resolvedDirective || !resolvedDirective.resolvedFileName) { + return; + } + var file = host.getSourceFile(resolvedDirective.resolvedFileName); + addReferencedFilesToTypeDirective(file, key); + }); + } + return { + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedDeclarationWithCollidingName: getReferencedDeclarationWithCollidingName, + isDeclarationWithCollidingName: isDeclarationWithCollidingName, + isValueAliasDeclaration: function (node) { + node = ts.getParseTreeNode(node); + return node ? isValueAliasDeclaration(node) : true; + }, + hasGlobalName: hasGlobalName, + isReferencedAliasDeclaration: function (node, checkChildren) { + node = ts.getParseTreeNode(node); + return node ? isReferencedAliasDeclaration(node, checkChildren) : true; + }, + getNodeCheckFlags: function (node) { + node = ts.getParseTreeNode(node); + return node ? getNodeCheckFlags(node) : 0; + }, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, + isDeclarationVisible: isDeclarationVisible, + isImplementationOfOverload: isImplementationOfOverload, + isRequiredInitializedParameter: isRequiredInitializedParameter, + isOptionalUninitializedParameterProperty: isOptionalUninitializedParameterProperty, + isExpandoFunctionDeclaration: isExpandoFunctionDeclaration, + getPropertiesOfContainerFunction: getPropertiesOfContainerFunction, + createTypeOfDeclaration: createTypeOfDeclaration, + createReturnTypeOfSignatureDeclaration: createReturnTypeOfSignatureDeclaration, + createTypeOfExpression: createTypeOfExpression, + createLiteralConstValue: createLiteralConstValue, + isSymbolAccessible: isSymbolAccessible, + isEntityNameVisible: isEntityNameVisible, + getConstantValue: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue); + return node ? getConstantValue(node) : undefined; + }, + collectLinkedAliases: collectLinkedAliases, + getReferencedValueDeclaration: getReferencedValueDeclaration, + getTypeReferenceSerializationKind: getTypeReferenceSerializationKind, + isOptionalParameter: isOptionalParameter, + moduleExportsSomeValue: moduleExportsSomeValue, + isArgumentsLocalBinding: isArgumentsLocalBinding, + getExternalModuleFileFromDeclaration: getExternalModuleFileFromDeclaration, + getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName, + getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol, + isLiteralConstDeclaration: isLiteralConstDeclaration, + isLateBound: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration); + var symbol = node && getSymbolOfNode(node); + return !!(symbol && ts.getCheckFlags(symbol) & 4096); + }, + getJsxFactoryEntity: function (location) { return location ? (getJsxNamespace(location), (ts.getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity; }, + getAllAccessorDeclarations: function (accessor) { + accessor = ts.getParseTreeNode(accessor, ts.isGetOrSetAccessorDeclaration); + var otherKind = accessor.kind === 164 ? 163 : 164; + var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(accessor), otherKind); + var firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor; + var secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor; + var setAccessor = accessor.kind === 164 ? accessor : otherAccessor; + var getAccessor = accessor.kind === 163 ? accessor : otherAccessor; + return { + firstAccessor: firstAccessor, + secondAccessor: secondAccessor, + setAccessor: setAccessor, + getAccessor: getAccessor + }; + }, + getSymbolOfExternalModuleSpecifier: function (moduleName) { return resolveExternalModuleNameWorker(moduleName, moduleName, undefined); }, + isBindingCapturedByNode: function (node, decl) { + var parseNode = ts.getParseTreeNode(node); + var parseDecl = ts.getParseTreeNode(decl); + return !!parseNode && !!parseDecl && (ts.isVariableDeclaration(parseDecl) || ts.isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl); + }, + getDeclarationStatementsForSourceFile: function (node, flags, tracker, bundled) { + var n = ts.getParseTreeNode(node); + ts.Debug.assert(n && n.kind === 290, "Non-sourcefile node passed into getDeclarationsForSourceFile"); + var sym = getSymbolOfNode(node); + if (!sym) { + return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled); + } + return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled); + } + }; + function isInHeritageClause(node) { + return node.parent && node.parent.kind === 216 && node.parent.parent && node.parent.parent.kind === 279; + } + function getTypeReferenceDirectivesForEntityName(node) { + if (!fileToDirective) { + return undefined; + } + var meaning = 788968 | 1920; + if ((node.kind === 75 && isInTypeQuery(node)) || (node.kind === 194 && !isInHeritageClause(node))) { + meaning = 111551 | 1048576; + } + var symbol = resolveEntityName(node, meaning, true); + return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined; + } + function getTypeReferenceDirectivesForSymbol(symbol, meaning) { + if (!fileToDirective) { + return undefined; + } + if (!isSymbolFromTypeDeclarationFile(symbol)) { + return undefined; + } + var typeReferenceDirectives; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.symbol && decl.symbol.flags & meaning) { + var file = ts.getSourceFileOfNode(decl); + var typeReferenceDirective = fileToDirective.get(file.path); + if (typeReferenceDirective) { + (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective); + } + else { + return undefined; + } + } + } + return typeReferenceDirectives; + } + function isSymbolFromTypeDeclarationFile(symbol) { + if (!symbol.declarations) { + return false; + } + var current = symbol; + while (true) { + var parent = getParentOfSymbol(current); + if (parent) { + current = parent; + } + else { + break; + } + } + if (current.valueDeclaration && current.valueDeclaration.kind === 290 && current.flags & 512) { + return false; + } + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var file = ts.getSourceFileOfNode(decl); + if (fileToDirective.has(file.path)) { + return true; + } + } + return false; + } + function addReferencedFilesToTypeDirective(file, key) { + if (fileToDirective.has(file.path)) + return; + fileToDirective.set(file.path, key); + for (var _i = 0, _a = file.referencedFiles; _i < _a.length; _i++) { + var fileName = _a[_i].fileName; + var resolvedFile = ts.resolveTripleslashReference(fileName, file.originalFileName); + var referencedFile = host.getSourceFile(resolvedFile); + if (referencedFile) { + addReferencedFilesToTypeDirective(referencedFile, key); + } + } + } + } + function getExternalModuleFileFromDeclaration(declaration) { + var specifier = declaration.kind === 249 ? ts.tryCast(declaration.name, ts.isStringLiteral) : ts.getExternalModuleName(declaration); + var moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, undefined); + if (!moduleSymbol) { + return undefined; + } + return ts.getDeclarationOfKind(moduleSymbol, 290); + } + function initializeTypeChecker() { + for (var _i = 0, _a = host.getSourceFiles(); _i < _a.length; _i++) { + var file = _a[_i]; + ts.bindSourceFile(file, compilerOptions); + } + amalgamatedDuplicates = ts.createMap(); + var augmentations; + for (var _b = 0, _c = host.getSourceFiles(); _b < _c.length; _b++) { + var file = _c[_b]; + if (file.redirectInfo) { + continue; + } + if (!ts.isExternalOrCommonJsModule(file)) { + var fileGlobalThisSymbol = file.locals.get("globalThis"); + if (fileGlobalThisSymbol) { + for (var _d = 0, _e = fileGlobalThisSymbol.declarations; _d < _e.length; _d++) { + var declaration = _e[_d]; + diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis")); + } + } + mergeSymbolTable(globals, file.locals); + } + if (file.jsGlobalAugmentations) { + mergeSymbolTable(globals, file.jsGlobalAugmentations); + } + if (file.patternAmbientModules && file.patternAmbientModules.length) { + patternAmbientModules = ts.concatenate(patternAmbientModules, file.patternAmbientModules); + } + if (file.moduleAugmentations.length) { + (augmentations || (augmentations = [])).push(file.moduleAugmentations); + } + if (file.symbol && file.symbol.globalExports) { + var source = file.symbol.globalExports; + source.forEach(function (sourceSymbol, id) { + if (!globals.has(id)) { + globals.set(id, sourceSymbol); + } + }); + } + } + if (augmentations) { + for (var _f = 0, augmentations_1 = augmentations; _f < augmentations_1.length; _f++) { + var list = augmentations_1[_f]; + for (var _g = 0, list_1 = list; _g < list_1.length; _g++) { + var augmentation = list_1[_g]; + if (!ts.isGlobalScopeAugmentation(augmentation.parent)) + continue; + mergeModuleAugmentation(augmentation); + } + } + } + addToSymbolTable(globals, builtinGlobals, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0); + getSymbolLinks(undefinedSymbol).type = undefinedWideningType; + getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments", 0, true); + getSymbolLinks(unknownSymbol).type = errorType; + getSymbolLinks(globalThisSymbol).type = createObjectType(16, globalThisSymbol); + globalArrayType = getGlobalType("Array", 1, true); + globalObjectType = getGlobalType("Object", 0, true); + globalFunctionType = getGlobalType("Function", 0, true); + globalCallableFunctionType = strictBindCallApply && getGlobalType("CallableFunction", 0, true) || globalFunctionType; + globalNewableFunctionType = strictBindCallApply && getGlobalType("NewableFunction", 0, true) || globalFunctionType; + globalStringType = getGlobalType("String", 0, true); + globalNumberType = getGlobalType("Number", 0, true); + globalBooleanType = getGlobalType("Boolean", 0, true); + globalRegExpType = getGlobalType("RegExp", 0, true); + anyArrayType = createArrayType(anyType); + autoArrayType = createArrayType(autoType); + if (autoArrayType === emptyObjectType) { + autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined); + } + globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType; + anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType; + globalThisType = getGlobalTypeOrUndefined("ThisType", 1); + if (augmentations) { + for (var _h = 0, augmentations_2 = augmentations; _h < augmentations_2.length; _h++) { + var list = augmentations_2[_h]; + for (var _j = 0, list_2 = list; _j < list_2.length; _j++) { + var augmentation = list_2[_j]; + if (ts.isGlobalScopeAugmentation(augmentation.parent)) + continue; + mergeModuleAugmentation(augmentation); + } + } + } + amalgamatedDuplicates.forEach(function (_a) { + var firstFile = _a.firstFile, secondFile = _a.secondFile, conflictingSymbols = _a.conflictingSymbols; + if (conflictingSymbols.size < 8) { + conflictingSymbols.forEach(function (_a, symbolName) { + var isBlockScoped = _a.isBlockScoped, firstFileLocations = _a.firstFileLocations, secondFileLocations = _a.secondFileLocations; + var message = isBlockScoped ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; + for (var _i = 0, firstFileLocations_1 = firstFileLocations; _i < firstFileLocations_1.length; _i++) { + var node = firstFileLocations_1[_i]; + addDuplicateDeclarationError(node, message, symbolName, secondFileLocations); + } + for (var _b = 0, secondFileLocations_1 = secondFileLocations; _b < secondFileLocations_1.length; _b++) { + var node = secondFileLocations_1[_b]; + addDuplicateDeclarationError(node, message, symbolName, firstFileLocations); + } + }); + } + else { + var list = ts.arrayFrom(conflictingSymbols.keys()).join(", "); + diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Conflicts_are_in_this_file))); + diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Conflicts_are_in_this_file))); + } + }); + amalgamatedDuplicates = undefined; + } + function checkExternalEmitHelpers(location, helpers) { + if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) { + var sourceFile = ts.getSourceFileOfNode(location); + if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 8388608)) { + var helpersModule = resolveHelpersModule(sourceFile, location); + if (helpersModule !== unknownSymbol) { + var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers; + for (var helper = 1; helper <= 524288; helper <<= 1) { + if (uncheckedHelpers & helper) { + var name = getHelperName(helper); + var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551); + if (!symbol) { + error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name); + } + } + } + } + requestedExternalEmitHelpers |= helpers; + } + } + } + function getHelperName(helper) { + switch (helper) { + case 1: return "__extends"; + case 2: return "__assign"; + case 4: return "__rest"; + case 8: return "__decorate"; + case 16: return "__metadata"; + case 32: return "__param"; + case 64: return "__awaiter"; + case 128: return "__generator"; + case 256: return "__values"; + case 512: return "__read"; + case 1024: return "__spread"; + case 2048: return "__spreadArrays"; + case 4096: return "__await"; + case 8192: return "__asyncGenerator"; + case 16384: return "__asyncDelegator"; + case 32768: return "__asyncValues"; + case 65536: return "__exportStar"; + case 131072: return "__makeTemplateObject"; + case 262144: return "__classPrivateFieldGet"; + case 524288: return "__classPrivateFieldSet"; + default: return ts.Debug.fail("Unrecognized helper"); + } + } + function resolveHelpersModule(node, errorNode) { + if (!externalHelpersModule) { + externalHelpersModule = resolveExternalModule(node, ts.externalHelpersModuleNameText, ts.Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol; + } + return externalHelpersModule; + } + function checkGrammarDecoratorsAndModifiers(node) { + return checkGrammarDecorators(node) || checkGrammarModifiers(node); + } + function checkGrammarDecorators(node) { + if (!node.decorators) { + return false; + } + if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) { + if (node.kind === 161 && !ts.nodeIsPresent(node.body)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload); + } + else { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here); + } + } + else if (node.kind === 163 || node.kind === 164) { + var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); + if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); + } + } + return false; + } + function checkGrammarModifiers(node) { + var quickResult = reportObviousModifierErrors(node); + if (quickResult !== undefined) { + return quickResult; + } + var lastStatic, lastDeclare, lastAsync, lastReadonly; + var flags = 0; + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (modifier.kind !== 138) { + if (node.kind === 158 || node.kind === 160) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_member, ts.tokenToString(modifier.kind)); + } + if (node.kind === 167) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_an_index_signature, ts.tokenToString(modifier.kind)); + } + } + switch (modifier.kind) { + case 81: + if (node.kind !== 248) { + return grammarErrorOnNode(node, ts.Diagnostics.A_class_member_cannot_have_the_0_keyword, ts.tokenToString(81)); + } + break; + case 119: + case 118: + case 117: + var text = visibilityToString(ts.modifierToFlag(modifier.kind)); + if (flags & 28) { + return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen); + } + else if (flags & 32) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); + } + else if (flags & 64) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly"); + } + else if (flags & 256) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async"); + } + else if (node.parent.kind === 250 || node.parent.kind === 290) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text); + } + else if (flags & 128) { + if (modifier.kind === 117) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract"); + } + else { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); + } + } + else if (ts.isPrivateIdentifierPropertyDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier); + } + flags |= ts.modifierToFlag(modifier.kind); + break; + case 120: + if (flags & 32) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); + } + else if (flags & 64) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly"); + } + else if (flags & 256) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async"); + } + else if (node.parent.kind === 250 || node.parent.kind === 290) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static"); + } + else if (node.kind === 156) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); + } + else if (flags & 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + else if (ts.isPrivateIdentifierPropertyDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "static"); + } + flags |= 32; + lastStatic = modifier; + break; + case 138: + if (flags & 64) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "readonly"); + } + else if (node.kind !== 159 && node.kind !== 158 && node.kind !== 167 && node.kind !== 156) { + return grammarErrorOnNode(modifier, ts.Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature); + } + flags |= 64; + lastReadonly = modifier; + break; + case 89: + if (flags & 1) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export"); + } + else if (flags & 2) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); + } + else if (flags & 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract"); + } + else if (flags & 256) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async"); + } + else if (ts.isClassLike(node.parent)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); + } + else if (node.kind === 156) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); + } + flags |= 1; + break; + case 84: + var container = node.parent.kind === 290 ? node.parent : node.parent.parent; + if (container.kind === 249 && !ts.isAmbientModule(container)) { + return grammarErrorOnNode(modifier, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + } + flags |= 512; + break; + case 130: + if (flags & 2) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); + } + else if (flags & 256) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } + else if (ts.isClassLike(node.parent) && !ts.isPropertyDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); + } + else if (node.kind === 156) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); + } + else if ((node.parent.flags & 8388608) && node.parent.kind === 250) { + return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); + } + else if (ts.isPrivateIdentifierPropertyDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare"); + } + flags |= 2; + lastDeclare = modifier; + break; + case 122: + if (flags & 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract"); + } + if (node.kind !== 245) { + if (node.kind !== 161 && + node.kind !== 159 && + node.kind !== 163 && + node.kind !== 164) { + return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration); + } + if (!(node.parent.kind === 245 && ts.hasModifier(node.parent, 128))) { + return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class); + } + if (flags & 32) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + if (flags & 8) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); + } + } + if (ts.isNamedDeclaration(node) && node.name.kind === 76) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract"); + } + flags |= 128; + break; + case 126: + if (flags & 256) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async"); + } + else if (flags & 2 || node.parent.flags & 8388608) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } + else if (node.kind === 156) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async"); + } + flags |= 256; + lastAsync = modifier; + break; + } + } + if (node.kind === 162) { + if (flags & 32) { + return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); + } + if (flags & 128) { + return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract"); + } + else if (flags & 256) { + return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async"); + } + else if (flags & 64) { + return grammarErrorOnNode(lastReadonly, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "readonly"); + } + return false; + } + else if ((node.kind === 254 || node.kind === 253) && flags & 2) { + return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare"); + } + else if (node.kind === 156 && (flags & 92) && ts.isBindingPattern(node.name)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern); + } + else if (node.kind === 156 && (flags & 92) && node.dotDotDotToken) { + return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter); + } + if (flags & 256) { + return checkGrammarAsyncModifier(node, lastAsync); + } + return false; + } + function reportObviousModifierErrors(node) { + return !node.modifiers + ? false + : shouldReportBadModifier(node) + ? grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here) + : undefined; + } + function shouldReportBadModifier(node) { + switch (node.kind) { + case 163: + case 164: + case 162: + case 159: + case 158: + case 161: + case 160: + case 167: + case 249: + case 254: + case 253: + case 260: + case 259: + case 201: + case 202: + case 156: + return false; + default: + if (node.parent.kind === 250 || node.parent.kind === 290) { + return false; + } + switch (node.kind) { + case 244: + return nodeHasAnyModifiersExcept(node, 126); + case 245: + return nodeHasAnyModifiersExcept(node, 122); + case 246: + case 225: + case 247: + return true; + case 248: + return nodeHasAnyModifiersExcept(node, 81); + default: + ts.Debug.fail(); + return false; + } + } + } + function nodeHasAnyModifiersExcept(node, allowedModifier) { + return node.modifiers.length > 1 || node.modifiers[0].kind !== allowedModifier; + } + function checkGrammarAsyncModifier(node, asyncModifier) { + switch (node.kind) { + case 161: + case 244: + case 201: + case 202: + return false; + } + return grammarErrorOnNode(asyncModifier, ts.Diagnostics._0_modifier_cannot_be_used_here, "async"); + } + function checkGrammarForDisallowedTrailingComma(list, diag) { + if (diag === void 0) { diag = ts.Diagnostics.Trailing_comma_not_allowed; } + if (list && list.hasTrailingComma) { + return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag); + } + return false; + } + function checkGrammarTypeParameterList(typeParameters, file) { + if (typeParameters && typeParameters.length === 0) { + var start = typeParameters.pos - "<".length; + var end = ts.skipTrivia(file.text, typeParameters.end) + ">".length; + return grammarErrorAtPos(file, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty); + } + return false; + } + function checkGrammarParameterList(parameters) { + var seenOptionalParameter = false; + var parameterCount = parameters.length; + for (var i = 0; i < parameterCount; i++) { + var parameter = parameters[i]; + if (parameter.dotDotDotToken) { + if (i !== (parameterCount - 1)) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + if (!(parameter.flags & 8388608)) { + checkGrammarForDisallowedTrailingComma(parameters, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer); + } + } + else if (parameter.questionToken) { + seenOptionalParameter = true; + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer); + } + } + else if (seenOptionalParameter && !parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter); + } + } + } + function getNonSimpleParameters(parameters) { + return ts.filter(parameters, function (parameter) { return !!parameter.initializer || ts.isBindingPattern(parameter.name) || ts.isRestParameter(parameter); }); + } + function checkGrammarForUseStrictSimpleParameterList(node) { + if (languageVersion >= 3) { + var useStrictDirective_1 = node.body && ts.isBlock(node.body) && ts.findUseStrictPrologue(node.body.statements); + if (useStrictDirective_1) { + var nonSimpleParameters = getNonSimpleParameters(node.parameters); + if (ts.length(nonSimpleParameters)) { + ts.forEach(nonSimpleParameters, function (parameter) { + ts.addRelatedInfo(error(parameter, ts.Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive), ts.createDiagnosticForNode(useStrictDirective_1, ts.Diagnostics.use_strict_directive_used_here)); + }); + var diagnostics_1 = nonSimpleParameters.map(function (parameter, index) { return (index === 0 ? ts.createDiagnosticForNode(parameter, ts.Diagnostics.Non_simple_parameter_declared_here) : ts.createDiagnosticForNode(parameter, ts.Diagnostics.and_here)); }); + ts.addRelatedInfo.apply(void 0, __spreadArrays([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_1)); + return true; + } + } + } + return false; + } + function checkGrammarFunctionLikeDeclaration(node) { + var file = ts.getSourceFileOfNode(node); + return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) || + checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file) || + (ts.isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node)); + } + function checkGrammarClassLikeDeclaration(node) { + var file = ts.getSourceFileOfNode(node); + return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file); + } + function checkGrammarArrowFunction(node, file) { + if (!ts.isArrowFunction(node)) { + return false; + } + var equalsGreaterThanToken = node.equalsGreaterThanToken; + var startLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line; + var endLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line; + return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, ts.Diagnostics.Line_terminator_not_permitted_before_arrow); + } + function checkGrammarIndexSignatureParameters(node) { + var parameter = node.parameters[0]; + if (node.parameters.length !== 1) { + if (parameter) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + else { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + } + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter); + } + if (ts.hasModifiers(parameter)) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer); + } + if (!parameter.type) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); + } + if (parameter.type.kind !== 143 && parameter.type.kind !== 140) { + var type = getTypeFromTypeNode(parameter.type); + if (type.flags & 4 || type.flags & 8) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead, ts.getTextOfNode(parameter.name), typeToString(type), typeToString(node.type ? getTypeFromTypeNode(node.type) : anyType)); + } + if (type.flags & 1048576 && allTypesAssignableToKind(type, 384, true)) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead); + } + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_either_string_or_number); + } + if (!node.type) { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation); + } + return false; + } + function checkGrammarIndexSignature(node) { + return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node); + } + function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) { + if (typeArguments && typeArguments.length === 0) { + var sourceFile = ts.getSourceFileOfNode(node); + var start = typeArguments.pos - "<".length; + var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length; + return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty); + } + return false; + } + function checkGrammarTypeArguments(node, typeArguments) { + return checkGrammarForDisallowedTrailingComma(typeArguments) || + checkGrammarForAtLeastOneTypeArgument(node, typeArguments); + } + function checkGrammarTaggedTemplateChain(node) { + if (node.questionDotToken || node.flags & 32) { + return grammarErrorOnNode(node.template, ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain); + } + return false; + } + function checkGrammarForOmittedArgument(args) { + if (args) { + for (var _i = 0, args_4 = args; _i < args_4.length; _i++) { + var arg = args_4[_i]; + if (arg.kind === 215) { + return grammarErrorAtPos(arg, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); + } + } + } + return false; + } + function checkGrammarArguments(args) { + return checkGrammarForOmittedArgument(args); + } + function checkGrammarHeritageClause(node) { + var types = node.types; + if (checkGrammarForDisallowedTrailingComma(types)) { + return true; + } + if (types && types.length === 0) { + var listType = ts.tokenToString(node.token); + return grammarErrorAtPos(node, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType); + } + return ts.some(types, checkGrammarExpressionWithTypeArguments); + } + function checkGrammarExpressionWithTypeArguments(node) { + return checkGrammarTypeArguments(node, node.typeArguments); + } + function checkGrammarClassDeclarationHeritageClauses(node) { + var seenExtendsClause = false; + var seenImplementsClause = false; + if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) { + for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { + var heritageClause = _a[_i]; + if (heritageClause.token === 90) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause); + } + if (heritageClause.types.length > 1) { + return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 113); + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); + } + seenImplementsClause = true; + } + checkGrammarHeritageClause(heritageClause); + } + } + } + function checkGrammarInterfaceDeclaration(node) { + var seenExtendsClause = false; + if (node.heritageClauses) { + for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { + var heritageClause = _a[_i]; + if (heritageClause.token === 90) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 113); + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); + } + checkGrammarHeritageClause(heritageClause); + } + } + return false; + } + function checkGrammarComputedPropertyName(node) { + if (node.kind !== 154) { + return false; + } + var computedPropertyName = node; + if (computedPropertyName.expression.kind === 209 && computedPropertyName.expression.operatorToken.kind === 27) { + return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); + } + return false; + } + function checkGrammarForGenerator(node) { + if (node.asteriskToken) { + ts.Debug.assert(node.kind === 244 || + node.kind === 201 || + node.kind === 161); + if (node.flags & 8388608) { + return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); + } + if (!node.body) { + return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator); + } + } + } + function checkGrammarForInvalidQuestionMark(questionToken, message) { + return !!questionToken && grammarErrorOnNode(questionToken, message); + } + function checkGrammarForInvalidExclamationToken(exclamationToken, message) { + return !!exclamationToken && grammarErrorOnNode(exclamationToken, message); + } + function checkGrammarObjectLiteralExpression(node, inDestructuring) { + var seen = ts.createUnderscoreEscapedMap(); + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.kind === 283) { + if (inDestructuring) { + var expression = ts.skipParentheses(prop.expression); + if (ts.isArrayLiteralExpression(expression) || ts.isObjectLiteralExpression(expression)) { + return grammarErrorOnNode(prop.expression, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); + } + } + continue; + } + var name = prop.name; + if (name.kind === 154) { + checkGrammarComputedPropertyName(name); + } + if (prop.kind === 282 && !inDestructuring && prop.objectAssignmentInitializer) { + return grammarErrorOnNode(prop.equalsToken, ts.Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment); + } + if (name.kind === 76) { + return grammarErrorOnNode(name, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + if (prop.modifiers) { + for (var _b = 0, _c = prop.modifiers; _b < _c.length; _b++) { + var mod = _c[_b]; + if (mod.kind !== 126 || prop.kind !== 161) { + grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod)); + } + } + } + var currentKind = void 0; + switch (prop.kind) { + case 282: + checkGrammarForInvalidExclamationToken(prop.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context); + case 281: + checkGrammarForInvalidQuestionMark(prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); + if (name.kind === 8) { + checkGrammarNumericLiteral(name); + } + currentKind = 4; + break; + case 161: + currentKind = 8; + break; + case 163: + currentKind = 1; + break; + case 164: + currentKind = 2; + break; + default: + throw ts.Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind); + } + if (!inDestructuring) { + var effectiveName = ts.getPropertyNameForPropertyNameNode(name); + if (effectiveName === undefined) { + continue; + } + var existingKind = seen.get(effectiveName); + if (!existingKind) { + seen.set(effectiveName, currentKind); + } + else { + if ((currentKind & 12) && (existingKind & 12)) { + grammarErrorOnNode(name, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name)); + } + else if ((currentKind & 3) && (existingKind & 3)) { + if (existingKind !== 3 && currentKind !== existingKind) { + seen.set(effectiveName, currentKind | existingKind); + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + } + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + } + } + } + } + } + function checkGrammarJsxElement(node) { + checkGrammarTypeArguments(node, node.typeArguments); + var seen = ts.createUnderscoreEscapedMap(); + for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) { + var attr = _a[_i]; + if (attr.kind === 275) { + continue; + } + var name = attr.name, initializer = attr.initializer; + if (!seen.get(name.escapedText)) { + seen.set(name.escapedText, true); + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name); + } + if (initializer && initializer.kind === 276 && !initializer.expression) { + return grammarErrorOnNode(initializer, ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression); + } + } + } + function checkGrammarJsxExpression(node) { + if (node.expression && ts.isCommaSequence(node.expression)) { + return grammarErrorOnNode(node.expression, ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array); + } + } + function checkGrammarForInOrForOfStatement(forInOrOfStatement) { + if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { + return true; + } + if (forInOrOfStatement.kind === 232 && forInOrOfStatement.awaitModifier) { + if ((forInOrOfStatement.flags & 32768) === 0) { + var sourceFile = ts.getSourceFileOfNode(forInOrOfStatement); + if (!hasParseDiagnostics(sourceFile)) { + var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator); + var func = ts.getContainingFunction(forInOrOfStatement); + if (func && func.kind !== 162) { + ts.Debug.assert((ts.getFunctionFlags(func) & 2) === 0, "Enclosing function should never be an async function."); + var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); + ts.addRelatedInfo(diagnostic, relatedInfo); + } + diagnostics.add(diagnostic); + return true; + } + return false; + } + } + if (forInOrOfStatement.initializer.kind === 243) { + var variableList = forInOrOfStatement.initializer; + if (!checkGrammarVariableDeclarationList(variableList)) { + var declarations = variableList.declarations; + if (!declarations.length) { + return false; + } + if (declarations.length > 1) { + var diagnostic = forInOrOfStatement.kind === 231 + ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement + : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; + return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); + } + var firstDeclaration = declarations[0]; + if (firstDeclaration.initializer) { + var diagnostic = forInOrOfStatement.kind === 231 + ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer + : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; + return grammarErrorOnNode(firstDeclaration.name, diagnostic); + } + if (firstDeclaration.type) { + var diagnostic = forInOrOfStatement.kind === 231 + ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation + : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; + return grammarErrorOnNode(firstDeclaration, diagnostic); + } + } + } + return false; + } + function checkGrammarAccessor(accessor) { + if (!(accessor.flags & 8388608)) { + if (languageVersion < 1) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher); + } + if (accessor.body === undefined && !ts.hasModifier(accessor, 128)) { + return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + } + if (accessor.body && ts.hasModifier(accessor, 128)) { + return grammarErrorOnNode(accessor, ts.Diagnostics.An_abstract_accessor_cannot_have_an_implementation); + } + if (accessor.typeParameters) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); + } + if (!doesAccessorHaveCorrectParameterCount(accessor)) { + return grammarErrorOnNode(accessor.name, accessor.kind === 163 ? + ts.Diagnostics.A_get_accessor_cannot_have_parameters : + ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter); + } + if (accessor.kind === 164) { + if (accessor.type) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); + } + var parameter = ts.Debug.assertDefined(ts.getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion."); + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter); + } + if (parameter.initializer) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer); + } + } + return false; + } + function doesAccessorHaveCorrectParameterCount(accessor) { + return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 163 ? 0 : 1); + } + function getAccessorThisParameter(accessor) { + if (accessor.parameters.length === (accessor.kind === 163 ? 1 : 2)) { + return ts.getThisParameter(accessor); + } + } + function checkGrammarTypeOperatorNode(node) { + if (node.operator === 147) { + if (node.type.kind !== 144) { + return grammarErrorOnNode(node.type, ts.Diagnostics._0_expected, ts.tokenToString(144)); + } + var parent = ts.walkUpParenthesizedTypes(node.parent); + switch (parent.kind) { + case 242: + var decl = parent; + if (decl.name.kind !== 75) { + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name); + } + if (!ts.isVariableDeclarationInVariableStatement(decl)) { + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement); + } + if (!(decl.parent.flags & 2)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const); + } + break; + case 159: + if (!ts.hasModifier(parent, 32) || + !ts.hasModifier(parent, 64)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly); + } + break; + case 158: + if (!ts.hasModifier(parent, 64)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly); + } + break; + default: + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_not_allowed_here); + } + } + else if (node.operator === 138) { + if (node.type.kind !== 174 && node.type.kind !== 175) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, ts.tokenToString(144)); + } + } + } + function checkGrammarForInvalidDynamicName(node, message) { + if (isNonBindableDynamicName(node)) { + return grammarErrorOnNode(node, message); + } + } + function checkGrammarMethod(node) { + if (checkGrammarFunctionLikeDeclaration(node)) { + return true; + } + if (node.kind === 161) { + if (node.parent.kind === 193) { + if (node.modifiers && !(node.modifiers.length === 1 && ts.first(node.modifiers).kind === 126)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); + } + else if (checkGrammarForInvalidQuestionMark(node.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional)) { + return true; + } + else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) { + return true; + } + else if (node.body === undefined) { + return grammarErrorAtPos(node, node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + } + if (checkGrammarForGenerator(node)) { + return true; + } + } + if (ts.isClassLike(node.parent)) { + if (node.flags & 8388608) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + else if (node.kind === 161 && !node.body) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + } + else if (node.parent.kind === 246) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + else if (node.parent.kind === 173) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + } + function checkGrammarBreakOrContinueStatement(node) { + var current = node; + while (current) { + if (ts.isFunctionLike(current)) { + return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); + } + switch (current.kind) { + case 238: + if (node.label && current.label.escapedText === node.label.escapedText) { + var isMisplacedContinueLabel = node.kind === 233 + && !ts.isIterationStatement(current.statement, true); + if (isMisplacedContinueLabel) { + return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); + } + return false; + } + break; + case 237: + if (node.kind === 234 && !node.label) { + return false; + } + break; + default: + if (ts.isIterationStatement(current, false) && !node.label) { + return false; + } + break; + } + current = current.parent; + } + if (node.label) { + var message = node.kind === 234 + ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement + : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; + return grammarErrorOnNode(node, message); + } + else { + var message = node.kind === 234 + ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement + : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; + return grammarErrorOnNode(node, message); + } + } + function checkGrammarBindingElement(node) { + if (node.dotDotDotToken) { + var elements = node.parent.elements; + if (node !== ts.last(elements)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + checkGrammarForDisallowedTrailingComma(elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + if (node.propertyName) { + return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_have_a_property_name); + } + if (node.initializer) { + return grammarErrorAtPos(node, node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); + } + } + } + function isStringOrNumberLiteralExpression(expr) { + return ts.isStringOrNumericLiteralLike(expr) || + expr.kind === 207 && expr.operator === 40 && + expr.operand.kind === 8; + } + function isBigIntLiteralExpression(expr) { + return expr.kind === 9 || + expr.kind === 207 && expr.operator === 40 && + expr.operand.kind === 9; + } + function isSimpleLiteralEnumReference(expr) { + if ((ts.isPropertyAccessExpression(expr) || (ts.isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) && + ts.isEntityNameExpression(expr.expression)) { + return !!(checkExpressionCached(expr).flags & 1024); + } + } + function checkAmbientInitializer(node) { + var initializer = node.initializer; + if (initializer) { + var isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) || + isSimpleLiteralEnumReference(initializer) || + initializer.kind === 106 || initializer.kind === 91 || + isBigIntLiteralExpression(initializer)); + var isConstOrReadonly = ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node); + if (isConstOrReadonly && !node.type) { + if (isInvalidInitializer) { + return grammarErrorOnNode(initializer, ts.Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference); + } + } + else { + return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); + } + if (!isConstOrReadonly || isInvalidInitializer) { + return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); + } + } + } + function checkGrammarVariableDeclaration(node) { + if (node.parent.parent.kind !== 231 && node.parent.parent.kind !== 232) { + if (node.flags & 8388608) { + checkAmbientInitializer(node); + } + else if (!node.initializer) { + if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer); + } + if (ts.isVarConst(node)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized); + } + } + } + if (node.exclamationToken && (node.parent.parent.kind !== 225 || !node.type || node.initializer || node.flags & 8388608)) { + return grammarErrorOnNode(node.exclamationToken, ts.Diagnostics.Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation); + } + var moduleKind = ts.getEmitModuleKind(compilerOptions); + if (moduleKind < ts.ModuleKind.ES2015 && moduleKind !== ts.ModuleKind.System && !compilerOptions.noEmit && + !(node.parent.parent.flags & 8388608) && ts.hasModifier(node.parent.parent, 1)) { + checkESModuleMarker(node.name); + } + var checkLetConstNames = (ts.isLet(node) || ts.isVarConst(node)); + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); + } + function checkESModuleMarker(name) { + if (name.kind === 75) { + if (ts.idText(name) === "__esModule") { + return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules); + } + } + else { + var elements = name.elements; + for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) { + var element = elements_1[_i]; + if (!ts.isOmittedExpression(element)) { + return checkESModuleMarker(element.name); + } + } + } + return false; + } + function checkGrammarNameInLetOrConstDeclarations(name) { + if (name.kind === 75) { + if (name.originalKeywordKind === 115) { + return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations); + } + } + else { + var elements = name.elements; + for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) { + var element = elements_2[_i]; + if (!ts.isOmittedExpression(element)) { + checkGrammarNameInLetOrConstDeclarations(element.name); + } + } + } + return false; + } + function checkGrammarVariableDeclarationList(declarationList) { + var declarations = declarationList.declarations; + if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) { + return true; + } + if (!declarationList.declarations.length) { + return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty); + } + return false; + } + function allowLetAndConstDeclarations(parent) { + switch (parent.kind) { + case 227: + case 228: + case 229: + case 236: + case 230: + case 231: + case 232: + return false; + case 238: + return allowLetAndConstDeclarations(parent.parent); + } + return true; + } + function checkGrammarForDisallowedLetOrConstStatement(node) { + if (!allowLetAndConstDeclarations(node.parent)) { + if (ts.isLet(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block); + } + else if (ts.isVarConst(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block); + } + } + } + function checkGrammarMetaProperty(node) { + var escapedText = node.name.escapedText; + switch (node.keywordToken) { + case 99: + if (escapedText !== "target") { + return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "target"); + } + break; + case 96: + if (escapedText !== "meta") { + return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "meta"); + } + break; + } + } + function hasParseDiagnostics(sourceFile) { + return sourceFile.parseDiagnostics.length > 0; + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function grammarErrorAtPos(nodeForSourceFile, start, length, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(nodeForSourceFile); + if (!hasParseDiagnostics(sourceFile)) { + diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function grammarErrorOnNode(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + diagnostics.add(ts.createDiagnosticForNode(node, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function checkGrammarConstructorTypeParameters(node) { + var jsdocTypeParameters = ts.isInJSFile(node) ? ts.getJSDocTypeParameterDeclarations(node) : undefined; + var range = node.typeParameters || jsdocTypeParameters && ts.firstOrUndefined(jsdocTypeParameters); + if (range) { + var pos = range.pos === range.end ? range.pos : ts.skipTrivia(ts.getSourceFileOfNode(node).text, range.pos); + return grammarErrorAtPos(node, pos, range.end - pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); + } + } + function checkGrammarConstructorTypeAnnotation(node) { + var type = ts.getEffectiveReturnTypeNode(node); + if (type) { + return grammarErrorOnNode(type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration); + } + } + function checkGrammarProperty(node) { + if (ts.isClassLike(node.parent)) { + if (ts.isStringLiteral(node.name) && node.name.text === "constructor") { + return grammarErrorOnNode(node.name, ts.Diagnostics.Classes_may_not_have_a_field_named_constructor); + } + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { + return true; + } + if (languageVersion < 2 && ts.isPrivateIdentifier(node.name)) { + return grammarErrorOnNode(node.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } + } + else if (node.parent.kind === 246) { + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { + return true; + } + if (node.initializer) { + return grammarErrorOnNode(node.initializer, ts.Diagnostics.An_interface_property_cannot_have_an_initializer); + } + } + else if (node.parent.kind === 173) { + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { + return true; + } + if (node.initializer) { + return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer); + } + } + if (node.flags & 8388608) { + checkAmbientInitializer(node); + } + if (ts.isPropertyDeclaration(node) && node.exclamationToken && (!ts.isClassLike(node.parent) || !node.type || node.initializer || + node.flags & 8388608 || ts.hasModifier(node, 32 | 128))) { + return grammarErrorOnNode(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context); + } + } + function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { + if (node.kind === 246 || + node.kind === 247 || + node.kind === 254 || + node.kind === 253 || + node.kind === 260 || + node.kind === 259 || + node.kind === 252 || + ts.hasModifier(node, 2 | 1 | 512)) { + return false; + } + return grammarErrorOnFirstToken(node, ts.Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier); + } + function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { + for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { + var decl = _a[_i]; + if (ts.isDeclaration(decl) || decl.kind === 225) { + if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { + return true; + } + } + } + return false; + } + function checkGrammarSourceFile(node) { + return !!(node.flags & 8388608) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node); + } + function checkGrammarStatementInAmbientContext(node) { + if (node.flags & 8388608) { + var links = getNodeLinks(node); + if (!links.hasReportedStatementInAmbientContext && (ts.isFunctionLike(node.parent) || ts.isAccessor(node.parent))) { + return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); + } + if (node.parent.kind === 223 || node.parent.kind === 250 || node.parent.kind === 290) { + var links_2 = getNodeLinks(node.parent); + if (!links_2.hasReportedStatementInAmbientContext) { + return links_2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); + } + } + else { + } + } + return false; + } + function checkGrammarNumericLiteral(node) { + if (node.numericLiteralFlags & 32) { + var diagnosticMessage = void 0; + if (languageVersion >= 1) { + diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0; + } + else if (ts.isChildOfNodeWithKind(node, 187)) { + diagnosticMessage = ts.Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0; + } + else if (ts.isChildOfNodeWithKind(node, 284)) { + diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0; + } + if (diagnosticMessage) { + var withMinus = ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 40; + var literal = (withMinus ? "-" : "") + "0o" + node.text; + return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal); + } + } + checkNumericLiteralValueSize(node); + return false; + } + function checkNumericLiteralValueSize(node) { + if (node.numericLiteralFlags & 16 || node.text.length <= 15 || node.text.indexOf(".") !== -1) { + return; + } + var apparentValue = +ts.getTextOfNode(node); + if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) { + return; + } + addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers)); + } + function checkGrammarBigIntLiteral(node) { + var literalType = ts.isLiteralTypeNode(node.parent) || + ts.isPrefixUnaryExpression(node.parent) && ts.isLiteralTypeNode(node.parent.parent); + if (!literalType) { + if (languageVersion < 7) { + if (grammarErrorOnNode(node, ts.Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) { + return true; + } + } + } + return false; + } + function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, ts.textSpanEnd(span), 0, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function getAmbientModules() { + if (!ambientModulesCache) { + ambientModulesCache = []; + globals.forEach(function (global, sym) { + if (ambientModuleSymbolRegex.test(sym)) { + ambientModulesCache.push(global); + } + }); + } + return ambientModulesCache; + } + function checkGrammarImportClause(node) { + if (node.isTypeOnly && node.name && node.namedBindings) { + return grammarErrorOnNode(node, ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both); + } + return false; + } + function checkGrammarImportCallExpression(node) { + if (moduleKind === ts.ModuleKind.ES2015) { + return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd); + } + if (node.typeArguments) { + return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments); + } + var nodeArguments = node.arguments; + if (nodeArguments.length !== 1) { + return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument); + } + checkGrammarForDisallowedTrailingComma(nodeArguments); + if (ts.isSpreadElement(nodeArguments[0])) { + return grammarErrorOnNode(nodeArguments[0], ts.Diagnostics.Specifier_of_dynamic_import_cannot_be_spread_element); + } + return false; + } + function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) { + var sourceObjectFlags = ts.getObjectFlags(source); + if (sourceObjectFlags & (4 | 16) && unionTarget.flags & 1048576) { + return ts.find(unionTarget.types, function (target) { + if (target.flags & 524288) { + var overlapObjFlags = sourceObjectFlags & ts.getObjectFlags(target); + if (overlapObjFlags & 4) { + return source.target === target.target; + } + if (overlapObjFlags & 16) { + return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol; + } + } + return false; + }); + } + } + function findBestTypeForObjectLiteral(source, unionTarget) { + if (ts.getObjectFlags(source) & 128 && forEachType(unionTarget, isArrayLikeType)) { + return ts.find(unionTarget.types, function (t) { return !isArrayLikeType(t); }); + } + } + function findBestTypeForInvokable(source, unionTarget) { + var signatureKind = 0; + var hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 || + (signatureKind = 1, getSignaturesOfType(source, signatureKind).length > 0); + if (hasSignatures) { + return ts.find(unionTarget.types, function (t) { return getSignaturesOfType(t, signatureKind).length > 0; }); + } + } + function findMostOverlappyType(source, unionTarget) { + var bestMatch; + var matchingCount = 0; + for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) { + var target = _a[_i]; + var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]); + if (overlap.flags & 4194304) { + bestMatch = target; + matchingCount = Infinity; + } + else if (overlap.flags & 1048576) { + var len = ts.length(ts.filter(overlap.types, isUnitType)); + if (len >= matchingCount) { + bestMatch = target; + matchingCount = len; + } + } + else if (isUnitType(overlap) && 1 >= matchingCount) { + bestMatch = target; + matchingCount = 1; + } + } + return bestMatch; + } + function filterPrimitivesIfContainsNonPrimitive(type) { + if (maybeTypeOfKind(type, 67108864)) { + var result = filterType(type, function (t) { return !(t.flags & 131068); }); + if (!(result.flags & 131072)) { + return result; + } + } + return type; + } + function findMatchingDiscriminantType(source, target, isRelatedTo) { + if (target.flags & 1048576 && source.flags & (2097152 | 524288)) { + var sourceProperties = getPropertiesOfType(source); + if (sourceProperties) { + var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target); + if (sourcePropertiesFiltered) { + return discriminateTypeByDiscriminableItems(target, ts.map(sourcePropertiesFiltered, function (p) { return [function () { return getTypeOfSymbol(p); }, p.escapedName]; }), isRelatedTo); + } + } + } + return undefined; + } + } + ts.createTypeChecker = createTypeChecker; + function isNotAccessor(declaration) { + return !ts.isAccessor(declaration); + } + function isNotOverload(declaration) { + return (declaration.kind !== 244 && declaration.kind !== 161) || + !!declaration.body; + } + function isDeclarationNameOrImportPropertyName(name) { + switch (name.parent.kind) { + case 258: + case 263: + return ts.isIdentifier(name); + default: + return ts.isDeclarationName(name); + } + } + function isSomeImportDeclaration(decl) { + switch (decl.kind) { + case 255: + case 253: + case 256: + case 258: + return true; + case 75: + return decl.parent.kind === 258; + default: + return false; + } + } + var JsxNames; + (function (JsxNames) { + JsxNames.JSX = "JSX"; + JsxNames.IntrinsicElements = "IntrinsicElements"; + JsxNames.ElementClass = "ElementClass"; + JsxNames.ElementAttributesPropertyNameContainer = "ElementAttributesProperty"; + JsxNames.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute"; + JsxNames.Element = "Element"; + JsxNames.IntrinsicAttributes = "IntrinsicAttributes"; + JsxNames.IntrinsicClassAttributes = "IntrinsicClassAttributes"; + JsxNames.LibraryManagedAttributes = "LibraryManagedAttributes"; + })(JsxNames || (JsxNames = {})); + function getIterationTypesKeyFromIterationTypeKind(typeKind) { + switch (typeKind) { + case 0: return "yieldType"; + case 1: return "returnType"; + case 2: return "nextType"; + } + } + function signatureHasRestParameter(s) { + return !!(s.flags & 1); + } + ts.signatureHasRestParameter = signatureHasRestParameter; + function signatureHasLiteralTypes(s) { + return !!(s.flags & 2); + } + ts.signatureHasLiteralTypes = signatureHasLiteralTypes; +})(ts || (ts = {})); +var ts; +(function (ts) { + function createSynthesizedNode(kind) { + var node = ts.createNode(kind, -1, -1); + node.flags |= 8; + return node; + } + function updateNode(updated, original) { + if (updated !== original) { + setOriginalNode(updated, original); + setTextRange(updated, original); + ts.aggregateTransformFlags(updated); + } + return updated; + } + ts.updateNode = updateNode; + function createNodeArray(elements, hasTrailingComma) { + if (!elements || elements === ts.emptyArray) { + elements = []; + } + else if (ts.isNodeArray(elements)) { + return elements; + } + var array = elements; + array.pos = -1; + array.end = -1; + array.hasTrailingComma = hasTrailingComma; + return array; + } + ts.createNodeArray = createNodeArray; + function getSynthesizedClone(node) { + if (node === undefined) { + return node; + } + var clone = createSynthesizedNode(node.kind); + clone.flags |= node.flags; + setOriginalNode(clone, node); + for (var key in node) { + if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) { + continue; + } + clone[key] = node[key]; + } + return clone; + } + ts.getSynthesizedClone = getSynthesizedClone; + function createLiteral(value, isSingleQuote) { + if (typeof value === "number") { + return createNumericLiteral(value + ""); + } + if (typeof value === "object" && "base10Value" in value) { + return createBigIntLiteral(ts.pseudoBigIntToString(value) + "n"); + } + if (typeof value === "boolean") { + return value ? createTrue() : createFalse(); + } + if (ts.isString(value)) { + var res = createStringLiteral(value); + if (isSingleQuote) + res.singleQuote = true; + return res; + } + return createLiteralFromNode(value); + } + ts.createLiteral = createLiteral; + function createNumericLiteral(value, numericLiteralFlags) { + if (numericLiteralFlags === void 0) { numericLiteralFlags = 0; } + var node = createSynthesizedNode(8); + node.text = value; + node.numericLiteralFlags = numericLiteralFlags; + return node; + } + ts.createNumericLiteral = createNumericLiteral; + function createBigIntLiteral(value) { + var node = createSynthesizedNode(9); + node.text = value; + return node; + } + ts.createBigIntLiteral = createBigIntLiteral; + function createStringLiteral(text) { + var node = createSynthesizedNode(10); + node.text = text; + return node; + } + ts.createStringLiteral = createStringLiteral; + function createRegularExpressionLiteral(text) { + var node = createSynthesizedNode(13); + node.text = text; + return node; + } + ts.createRegularExpressionLiteral = createRegularExpressionLiteral; + function createLiteralFromNode(sourceNode) { + var node = createStringLiteral(ts.getTextOfIdentifierOrLiteral(sourceNode)); + node.textSourceNode = sourceNode; + return node; + } + function createIdentifier(text, typeArguments) { + var node = createSynthesizedNode(75); + node.escapedText = ts.escapeLeadingUnderscores(text); + node.originalKeywordKind = text ? ts.stringToToken(text) : 0; + node.autoGenerateFlags = 0; + node.autoGenerateId = 0; + if (typeArguments) { + node.typeArguments = createNodeArray(typeArguments); + } + return node; + } + ts.createIdentifier = createIdentifier; + function updateIdentifier(node, typeArguments) { + return node.typeArguments !== typeArguments + ? updateNode(createIdentifier(ts.idText(node), typeArguments), node) + : node; + } + ts.updateIdentifier = updateIdentifier; + var nextAutoGenerateId = 0; + function createTempVariable(recordTempVariable, reservedInNestedScopes) { + var name = createIdentifier(""); + name.autoGenerateFlags = 1; + name.autoGenerateId = nextAutoGenerateId; + nextAutoGenerateId++; + if (recordTempVariable) { + recordTempVariable(name); + } + if (reservedInNestedScopes) { + name.autoGenerateFlags |= 8; + } + return name; + } + ts.createTempVariable = createTempVariable; + function createLoopVariable() { + var name = createIdentifier(""); + name.autoGenerateFlags = 2; + name.autoGenerateId = nextAutoGenerateId; + nextAutoGenerateId++; + return name; + } + ts.createLoopVariable = createLoopVariable; + function createUniqueName(text) { + var name = createIdentifier(text); + name.autoGenerateFlags = 3; + name.autoGenerateId = nextAutoGenerateId; + nextAutoGenerateId++; + return name; + } + ts.createUniqueName = createUniqueName; + function createOptimisticUniqueName(text) { + var name = createIdentifier(text); + name.autoGenerateFlags = 3 | 16; + name.autoGenerateId = nextAutoGenerateId; + nextAutoGenerateId++; + return name; + } + ts.createOptimisticUniqueName = createOptimisticUniqueName; + function createFileLevelUniqueName(text) { + var name = createOptimisticUniqueName(text); + name.autoGenerateFlags |= 32; + return name; + } + ts.createFileLevelUniqueName = createFileLevelUniqueName; + function getGeneratedNameForNode(node, flags) { + var name = createIdentifier(node && ts.isIdentifier(node) ? ts.idText(node) : ""); + name.autoGenerateFlags = 4 | flags; + name.autoGenerateId = nextAutoGenerateId; + name.original = node; + nextAutoGenerateId++; + return name; + } + ts.getGeneratedNameForNode = getGeneratedNameForNode; + function createPrivateIdentifier(text) { + if (text[0] !== "#") { + ts.Debug.fail("First character of private identifier must be #: " + text); + } + var node = createSynthesizedNode(76); + node.escapedText = ts.escapeLeadingUnderscores(text); + return node; + } + ts.createPrivateIdentifier = createPrivateIdentifier; + function createToken(token) { + return createSynthesizedNode(token); + } + ts.createToken = createToken; + function createSuper() { + return createSynthesizedNode(102); + } + ts.createSuper = createSuper; + function createThis() { + return createSynthesizedNode(104); + } + ts.createThis = createThis; + function createNull() { + return createSynthesizedNode(100); + } + ts.createNull = createNull; + function createTrue() { + return createSynthesizedNode(106); + } + ts.createTrue = createTrue; + function createFalse() { + return createSynthesizedNode(91); + } + ts.createFalse = createFalse; + function createModifier(kind) { + return createToken(kind); + } + ts.createModifier = createModifier; + function createModifiersFromModifierFlags(flags) { + var result = []; + if (flags & 1) { + result.push(createModifier(89)); + } + if (flags & 2) { + result.push(createModifier(130)); + } + if (flags & 512) { + result.push(createModifier(84)); + } + if (flags & 2048) { + result.push(createModifier(81)); + } + if (flags & 4) { + result.push(createModifier(119)); + } + if (flags & 8) { + result.push(createModifier(117)); + } + if (flags & 16) { + result.push(createModifier(118)); + } + if (flags & 128) { + result.push(createModifier(122)); + } + if (flags & 32) { + result.push(createModifier(120)); + } + if (flags & 64) { + result.push(createModifier(138)); + } + if (flags & 256) { + result.push(createModifier(126)); + } + return result; + } + ts.createModifiersFromModifierFlags = createModifiersFromModifierFlags; + function createQualifiedName(left, right) { + var node = createSynthesizedNode(153); + node.left = left; + node.right = asName(right); + return node; + } + ts.createQualifiedName = createQualifiedName; + function updateQualifiedName(node, left, right) { + return node.left !== left + || node.right !== right + ? updateNode(createQualifiedName(left, right), node) + : node; + } + ts.updateQualifiedName = updateQualifiedName; + function parenthesizeForComputedName(expression) { + return ts.isCommaSequence(expression) + ? createParen(expression) + : expression; + } + function createComputedPropertyName(expression) { + var node = createSynthesizedNode(154); + node.expression = parenthesizeForComputedName(expression); + return node; + } + ts.createComputedPropertyName = createComputedPropertyName; + function updateComputedPropertyName(node, expression) { + return node.expression !== expression + ? updateNode(createComputedPropertyName(expression), node) + : node; + } + ts.updateComputedPropertyName = updateComputedPropertyName; + function createTypeParameterDeclaration(name, constraint, defaultType) { + var node = createSynthesizedNode(155); + node.name = asName(name); + node.constraint = constraint; + node.default = defaultType; + return node; + } + ts.createTypeParameterDeclaration = createTypeParameterDeclaration; + function updateTypeParameterDeclaration(node, name, constraint, defaultType) { + return node.name !== name + || node.constraint !== constraint + || node.default !== defaultType + ? updateNode(createTypeParameterDeclaration(name, constraint, defaultType), node) + : node; + } + ts.updateTypeParameterDeclaration = updateTypeParameterDeclaration; + function createParameter(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + var node = createSynthesizedNode(156); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.dotDotDotToken = dotDotDotToken; + node.name = asName(name); + node.questionToken = questionToken; + node.type = type; + node.initializer = initializer ? ts.parenthesizeExpressionForList(initializer) : undefined; + return node; + } + ts.createParameter = createParameter; + function updateParameter(node, decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + || node.initializer !== initializer + ? updateNode(createParameter(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer), node) + : node; + } + ts.updateParameter = updateParameter; + function createDecorator(expression) { + var node = createSynthesizedNode(157); + node.expression = ts.parenthesizeForAccess(expression); + return node; + } + ts.createDecorator = createDecorator; + function updateDecorator(node, expression) { + return node.expression !== expression + ? updateNode(createDecorator(expression), node) + : node; + } + ts.updateDecorator = updateDecorator; + function createPropertySignature(modifiers, name, questionToken, type, initializer) { + var node = createSynthesizedNode(158); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.questionToken = questionToken; + node.type = type; + node.initializer = initializer; + return node; + } + ts.createPropertySignature = createPropertySignature; + function updatePropertySignature(node, modifiers, name, questionToken, type, initializer) { + return node.modifiers !== modifiers + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + || node.initializer !== initializer + ? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node) + : node; + } + ts.updatePropertySignature = updatePropertySignature; + function createProperty(decorators, modifiers, name, questionOrExclamationToken, type, initializer) { + var node = createSynthesizedNode(159); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.questionToken = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 57 ? questionOrExclamationToken : undefined; + node.exclamationToken = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 53 ? questionOrExclamationToken : undefined; + node.type = type; + node.initializer = initializer; + return node; + } + ts.createProperty = createProperty; + function updateProperty(node, decorators, modifiers, name, questionOrExclamationToken, type, initializer) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.questionToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 57 ? questionOrExclamationToken : undefined) + || node.exclamationToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 53 ? questionOrExclamationToken : undefined) + || node.type !== type + || node.initializer !== initializer + ? updateNode(createProperty(decorators, modifiers, name, questionOrExclamationToken, type, initializer), node) + : node; + } + ts.updateProperty = updateProperty; + function createMethodSignature(typeParameters, parameters, type, name, questionToken) { + var node = createSignatureDeclaration(160, typeParameters, parameters, type); + node.name = asName(name); + node.questionToken = questionToken; + return node; + } + ts.createMethodSignature = createMethodSignature; + function updateMethodSignature(node, typeParameters, parameters, type, name, questionToken) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.name !== name + || node.questionToken !== questionToken + ? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node) + : node; + } + ts.updateMethodSignature = updateMethodSignature; + function createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + var node = createSynthesizedNode(161); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.asteriskToken = asteriskToken; + node.name = asName(name); + node.questionToken = questionToken; + node.typeParameters = asNodeArray(typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + node.body = body; + return node; + } + ts.createMethod = createMethod; + function createMethodCall(object, methodName, argumentsList) { + return createCall(createPropertyAccess(object, asName(methodName)), undefined, argumentsList); + } + function createGlobalMethodCall(globalObjectName, methodName, argumentsList) { + return createMethodCall(createIdentifier(globalObjectName), methodName, argumentsList); + } + function createObjectDefinePropertyCall(target, propertyName, attributes) { + return createGlobalMethodCall("Object", "defineProperty", [target, asExpression(propertyName), attributes]); + } + ts.createObjectDefinePropertyCall = createObjectDefinePropertyCall; + function tryAddPropertyAssignment(properties, propertyName, expression) { + if (expression) { + properties.push(createPropertyAssignment(propertyName, expression)); + return true; + } + return false; + } + function createPropertyDescriptor(attributes, singleLine) { + var properties = []; + tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable)); + tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable)); + var isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable)); + isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData; + var isAccessor = tryAddPropertyAssignment(properties, "get", attributes.get); + isAccessor = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor; + ts.Debug.assert(!(isData && isAccessor), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor."); + return createObjectLiteral(properties, !singleLine); + } + ts.createPropertyDescriptor = createPropertyDescriptor; + function updateMethod(node, decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.name !== name + || node.questionToken !== questionToken + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? updateNode(createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node) + : node; + } + ts.updateMethod = updateMethod; + function createConstructor(decorators, modifiers, parameters, body) { + var node = createSynthesizedNode(162); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.typeParameters = undefined; + node.parameters = createNodeArray(parameters); + node.type = undefined; + node.body = body; + return node; + } + ts.createConstructor = createConstructor; + function updateConstructor(node, decorators, modifiers, parameters, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.parameters !== parameters + || node.body !== body + ? updateNode(createConstructor(decorators, modifiers, parameters, body), node) + : node; + } + ts.updateConstructor = updateConstructor; + function createGetAccessor(decorators, modifiers, name, parameters, type, body) { + var node = createSynthesizedNode(163); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = undefined; + node.parameters = createNodeArray(parameters); + node.type = type; + node.body = body; + return node; + } + ts.createGetAccessor = createGetAccessor; + function updateGetAccessor(node, decorators, modifiers, name, parameters, type, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? updateNode(createGetAccessor(decorators, modifiers, name, parameters, type, body), node) + : node; + } + ts.updateGetAccessor = updateGetAccessor; + function createSetAccessor(decorators, modifiers, name, parameters, body) { + var node = createSynthesizedNode(164); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = undefined; + node.parameters = createNodeArray(parameters); + node.body = body; + return node; + } + ts.createSetAccessor = createSetAccessor; + function updateSetAccessor(node, decorators, modifiers, name, parameters, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.parameters !== parameters + || node.body !== body + ? updateNode(createSetAccessor(decorators, modifiers, name, parameters, body), node) + : node; + } + ts.updateSetAccessor = updateSetAccessor; + function createCallSignature(typeParameters, parameters, type) { + return createSignatureDeclaration(165, typeParameters, parameters, type); + } + ts.createCallSignature = createCallSignature; + function updateCallSignature(node, typeParameters, parameters, type) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + ts.updateCallSignature = updateCallSignature; + function createConstructSignature(typeParameters, parameters, type) { + return createSignatureDeclaration(166, typeParameters, parameters, type); + } + ts.createConstructSignature = createConstructSignature; + function updateConstructSignature(node, typeParameters, parameters, type) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + ts.updateConstructSignature = updateConstructSignature; + function createIndexSignature(decorators, modifiers, parameters, type) { + var node = createSynthesizedNode(167); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.parameters = createNodeArray(parameters); + node.type = type; + return node; + } + ts.createIndexSignature = createIndexSignature; + function updateIndexSignature(node, decorators, modifiers, parameters, type) { + return node.parameters !== parameters + || node.type !== type + || node.decorators !== decorators + || node.modifiers !== modifiers + ? updateNode(createIndexSignature(decorators, modifiers, parameters, type), node) + : node; + } + ts.updateIndexSignature = updateIndexSignature; + function createSignatureDeclaration(kind, typeParameters, parameters, type, typeArguments) { + var node = createSynthesizedNode(kind); + node.typeParameters = asNodeArray(typeParameters); + node.parameters = asNodeArray(parameters); + node.type = type; + node.typeArguments = asNodeArray(typeArguments); + return node; + } + ts.createSignatureDeclaration = createSignatureDeclaration; + function updateSignatureDeclaration(node, typeParameters, parameters, type) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? updateNode(createSignatureDeclaration(node.kind, typeParameters, parameters, type), node) + : node; + } + function createKeywordTypeNode(kind) { + return createSynthesizedNode(kind); + } + ts.createKeywordTypeNode = createKeywordTypeNode; + function createTypePredicateNode(parameterName, type) { + return createTypePredicateNodeWithModifier(undefined, parameterName, type); + } + ts.createTypePredicateNode = createTypePredicateNode; + function createTypePredicateNodeWithModifier(assertsModifier, parameterName, type) { + var node = createSynthesizedNode(168); + node.assertsModifier = assertsModifier; + node.parameterName = asName(parameterName); + node.type = type; + return node; + } + ts.createTypePredicateNodeWithModifier = createTypePredicateNodeWithModifier; + function updateTypePredicateNode(node, parameterName, type) { + return updateTypePredicateNodeWithModifier(node, node.assertsModifier, parameterName, type); + } + ts.updateTypePredicateNode = updateTypePredicateNode; + function updateTypePredicateNodeWithModifier(node, assertsModifier, parameterName, type) { + return node.assertsModifier !== assertsModifier + || node.parameterName !== parameterName + || node.type !== type + ? updateNode(createTypePredicateNodeWithModifier(assertsModifier, parameterName, type), node) + : node; + } + ts.updateTypePredicateNodeWithModifier = updateTypePredicateNodeWithModifier; + function createTypeReferenceNode(typeName, typeArguments) { + var node = createSynthesizedNode(169); + node.typeName = asName(typeName); + node.typeArguments = typeArguments && ts.parenthesizeTypeParameters(typeArguments); + return node; + } + ts.createTypeReferenceNode = createTypeReferenceNode; + function updateTypeReferenceNode(node, typeName, typeArguments) { + return node.typeName !== typeName + || node.typeArguments !== typeArguments + ? updateNode(createTypeReferenceNode(typeName, typeArguments), node) + : node; + } + ts.updateTypeReferenceNode = updateTypeReferenceNode; + function createFunctionTypeNode(typeParameters, parameters, type) { + return createSignatureDeclaration(170, typeParameters, parameters, type); + } + ts.createFunctionTypeNode = createFunctionTypeNode; + function updateFunctionTypeNode(node, typeParameters, parameters, type) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + ts.updateFunctionTypeNode = updateFunctionTypeNode; + function createConstructorTypeNode(typeParameters, parameters, type) { + return createSignatureDeclaration(171, typeParameters, parameters, type); + } + ts.createConstructorTypeNode = createConstructorTypeNode; + function updateConstructorTypeNode(node, typeParameters, parameters, type) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + ts.updateConstructorTypeNode = updateConstructorTypeNode; + function createTypeQueryNode(exprName) { + var node = createSynthesizedNode(172); + node.exprName = exprName; + return node; + } + ts.createTypeQueryNode = createTypeQueryNode; + function updateTypeQueryNode(node, exprName) { + return node.exprName !== exprName + ? updateNode(createTypeQueryNode(exprName), node) + : node; + } + ts.updateTypeQueryNode = updateTypeQueryNode; + function createTypeLiteralNode(members) { + var node = createSynthesizedNode(173); + node.members = createNodeArray(members); + return node; + } + ts.createTypeLiteralNode = createTypeLiteralNode; + function updateTypeLiteralNode(node, members) { + return node.members !== members + ? updateNode(createTypeLiteralNode(members), node) + : node; + } + ts.updateTypeLiteralNode = updateTypeLiteralNode; + function createArrayTypeNode(elementType) { + var node = createSynthesizedNode(174); + node.elementType = ts.parenthesizeArrayTypeMember(elementType); + return node; + } + ts.createArrayTypeNode = createArrayTypeNode; + function updateArrayTypeNode(node, elementType) { + return node.elementType !== elementType + ? updateNode(createArrayTypeNode(elementType), node) + : node; + } + ts.updateArrayTypeNode = updateArrayTypeNode; + function createTupleTypeNode(elementTypes) { + var node = createSynthesizedNode(175); + node.elementTypes = createNodeArray(elementTypes); + return node; + } + ts.createTupleTypeNode = createTupleTypeNode; + function updateTupleTypeNode(node, elementTypes) { + return node.elementTypes !== elementTypes + ? updateNode(createTupleTypeNode(elementTypes), node) + : node; + } + ts.updateTupleTypeNode = updateTupleTypeNode; + function createOptionalTypeNode(type) { + var node = createSynthesizedNode(176); + node.type = ts.parenthesizeArrayTypeMember(type); + return node; + } + ts.createOptionalTypeNode = createOptionalTypeNode; + function updateOptionalTypeNode(node, type) { + return node.type !== type + ? updateNode(createOptionalTypeNode(type), node) + : node; + } + ts.updateOptionalTypeNode = updateOptionalTypeNode; + function createRestTypeNode(type) { + var node = createSynthesizedNode(177); + node.type = type; + return node; + } + ts.createRestTypeNode = createRestTypeNode; + function updateRestTypeNode(node, type) { + return node.type !== type + ? updateNode(createRestTypeNode(type), node) + : node; + } + ts.updateRestTypeNode = updateRestTypeNode; + function createUnionTypeNode(types) { + return createUnionOrIntersectionTypeNode(178, types); + } + ts.createUnionTypeNode = createUnionTypeNode; + function updateUnionTypeNode(node, types) { + return updateUnionOrIntersectionTypeNode(node, types); + } + ts.updateUnionTypeNode = updateUnionTypeNode; + function createIntersectionTypeNode(types) { + return createUnionOrIntersectionTypeNode(179, types); + } + ts.createIntersectionTypeNode = createIntersectionTypeNode; + function updateIntersectionTypeNode(node, types) { + return updateUnionOrIntersectionTypeNode(node, types); + } + ts.updateIntersectionTypeNode = updateIntersectionTypeNode; + function createUnionOrIntersectionTypeNode(kind, types) { + var node = createSynthesizedNode(kind); + node.types = ts.parenthesizeElementTypeMembers(types); + return node; + } + ts.createUnionOrIntersectionTypeNode = createUnionOrIntersectionTypeNode; + function updateUnionOrIntersectionTypeNode(node, types) { + return node.types !== types + ? updateNode(createUnionOrIntersectionTypeNode(node.kind, types), node) + : node; + } + function createConditionalTypeNode(checkType, extendsType, trueType, falseType) { + var node = createSynthesizedNode(180); + node.checkType = ts.parenthesizeConditionalTypeMember(checkType); + node.extendsType = ts.parenthesizeConditionalTypeMember(extendsType); + node.trueType = trueType; + node.falseType = falseType; + return node; + } + ts.createConditionalTypeNode = createConditionalTypeNode; + function updateConditionalTypeNode(node, checkType, extendsType, trueType, falseType) { + return node.checkType !== checkType + || node.extendsType !== extendsType + || node.trueType !== trueType + || node.falseType !== falseType + ? updateNode(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node) + : node; + } + ts.updateConditionalTypeNode = updateConditionalTypeNode; + function createInferTypeNode(typeParameter) { + var node = createSynthesizedNode(181); + node.typeParameter = typeParameter; + return node; + } + ts.createInferTypeNode = createInferTypeNode; + function updateInferTypeNode(node, typeParameter) { + return node.typeParameter !== typeParameter + ? updateNode(createInferTypeNode(typeParameter), node) + : node; + } + ts.updateInferTypeNode = updateInferTypeNode; + function createImportTypeNode(argument, qualifier, typeArguments, isTypeOf) { + var node = createSynthesizedNode(188); + node.argument = argument; + node.qualifier = qualifier; + node.typeArguments = ts.parenthesizeTypeParameters(typeArguments); + node.isTypeOf = isTypeOf; + return node; + } + ts.createImportTypeNode = createImportTypeNode; + function updateImportTypeNode(node, argument, qualifier, typeArguments, isTypeOf) { + return node.argument !== argument + || node.qualifier !== qualifier + || node.typeArguments !== typeArguments + || node.isTypeOf !== isTypeOf + ? updateNode(createImportTypeNode(argument, qualifier, typeArguments, isTypeOf), node) + : node; + } + ts.updateImportTypeNode = updateImportTypeNode; + function createParenthesizedType(type) { + var node = createSynthesizedNode(182); + node.type = type; + return node; + } + ts.createParenthesizedType = createParenthesizedType; + function updateParenthesizedType(node, type) { + return node.type !== type + ? updateNode(createParenthesizedType(type), node) + : node; + } + ts.updateParenthesizedType = updateParenthesizedType; + function createThisTypeNode() { + return createSynthesizedNode(183); + } + ts.createThisTypeNode = createThisTypeNode; + function createTypeOperatorNode(operatorOrType, type) { + var node = createSynthesizedNode(184); + node.operator = typeof operatorOrType === "number" ? operatorOrType : 134; + node.type = ts.parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type : operatorOrType); + return node; + } + ts.createTypeOperatorNode = createTypeOperatorNode; + function updateTypeOperatorNode(node, type) { + return node.type !== type ? updateNode(createTypeOperatorNode(node.operator, type), node) : node; + } + ts.updateTypeOperatorNode = updateTypeOperatorNode; + function createIndexedAccessTypeNode(objectType, indexType) { + var node = createSynthesizedNode(185); + node.objectType = ts.parenthesizeElementTypeMember(objectType); + node.indexType = indexType; + return node; + } + ts.createIndexedAccessTypeNode = createIndexedAccessTypeNode; + function updateIndexedAccessTypeNode(node, objectType, indexType) { + return node.objectType !== objectType + || node.indexType !== indexType + ? updateNode(createIndexedAccessTypeNode(objectType, indexType), node) + : node; + } + ts.updateIndexedAccessTypeNode = updateIndexedAccessTypeNode; + function createMappedTypeNode(readonlyToken, typeParameter, questionToken, type) { + var node = createSynthesizedNode(186); + node.readonlyToken = readonlyToken; + node.typeParameter = typeParameter; + node.questionToken = questionToken; + node.type = type; + return node; + } + ts.createMappedTypeNode = createMappedTypeNode; + function updateMappedTypeNode(node, readonlyToken, typeParameter, questionToken, type) { + return node.readonlyToken !== readonlyToken + || node.typeParameter !== typeParameter + || node.questionToken !== questionToken + || node.type !== type + ? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node) + : node; + } + ts.updateMappedTypeNode = updateMappedTypeNode; + function createLiteralTypeNode(literal) { + var node = createSynthesizedNode(187); + node.literal = literal; + return node; + } + ts.createLiteralTypeNode = createLiteralTypeNode; + function updateLiteralTypeNode(node, literal) { + return node.literal !== literal + ? updateNode(createLiteralTypeNode(literal), node) + : node; + } + ts.updateLiteralTypeNode = updateLiteralTypeNode; + function createObjectBindingPattern(elements) { + var node = createSynthesizedNode(189); + node.elements = createNodeArray(elements); + return node; + } + ts.createObjectBindingPattern = createObjectBindingPattern; + function updateObjectBindingPattern(node, elements) { + return node.elements !== elements + ? updateNode(createObjectBindingPattern(elements), node) + : node; + } + ts.updateObjectBindingPattern = updateObjectBindingPattern; + function createArrayBindingPattern(elements) { + var node = createSynthesizedNode(190); + node.elements = createNodeArray(elements); + return node; + } + ts.createArrayBindingPattern = createArrayBindingPattern; + function updateArrayBindingPattern(node, elements) { + return node.elements !== elements + ? updateNode(createArrayBindingPattern(elements), node) + : node; + } + ts.updateArrayBindingPattern = updateArrayBindingPattern; + function createBindingElement(dotDotDotToken, propertyName, name, initializer) { + var node = createSynthesizedNode(191); + node.dotDotDotToken = dotDotDotToken; + node.propertyName = asName(propertyName); + node.name = asName(name); + node.initializer = initializer; + return node; + } + ts.createBindingElement = createBindingElement; + function updateBindingElement(node, dotDotDotToken, propertyName, name, initializer) { + return node.propertyName !== propertyName + || node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.initializer !== initializer + ? updateNode(createBindingElement(dotDotDotToken, propertyName, name, initializer), node) + : node; + } + ts.updateBindingElement = updateBindingElement; + function createArrayLiteral(elements, multiLine) { + var node = createSynthesizedNode(192); + node.elements = ts.parenthesizeListElements(createNodeArray(elements)); + if (multiLine) + node.multiLine = true; + return node; + } + ts.createArrayLiteral = createArrayLiteral; + function updateArrayLiteral(node, elements) { + return node.elements !== elements + ? updateNode(createArrayLiteral(elements, node.multiLine), node) + : node; + } + ts.updateArrayLiteral = updateArrayLiteral; + function createObjectLiteral(properties, multiLine) { + var node = createSynthesizedNode(193); + node.properties = createNodeArray(properties); + if (multiLine) + node.multiLine = true; + return node; + } + ts.createObjectLiteral = createObjectLiteral; + function updateObjectLiteral(node, properties) { + return node.properties !== properties + ? updateNode(createObjectLiteral(properties, node.multiLine), node) + : node; + } + ts.updateObjectLiteral = updateObjectLiteral; + function createPropertyAccess(expression, name) { + var node = createSynthesizedNode(194); + node.expression = ts.parenthesizeForAccess(expression); + node.name = asName(name); + setEmitFlags(node, 131072); + return node; + } + ts.createPropertyAccess = createPropertyAccess; + function updatePropertyAccess(node, expression, name) { + if (ts.isOptionalChain(node) && ts.isIdentifier(node.name) && ts.isIdentifier(name)) { + var theNode = node; + return updatePropertyAccessChain(theNode, expression, node.questionDotToken, name); + } + return node.expression !== expression + || node.name !== name + ? updateNode(setEmitFlags(createPropertyAccess(expression, name), ts.getEmitFlags(node)), node) + : node; + } + ts.updatePropertyAccess = updatePropertyAccess; + function createPropertyAccessChain(expression, questionDotToken, name) { + var node = createSynthesizedNode(194); + node.flags |= 32; + node.expression = ts.parenthesizeForAccess(expression); + node.questionDotToken = questionDotToken; + node.name = asName(name); + setEmitFlags(node, 131072); + return node; + } + ts.createPropertyAccessChain = createPropertyAccessChain; + function updatePropertyAccessChain(node, expression, questionDotToken, name) { + ts.Debug.assert(!!(node.flags & 32), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead."); + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.name !== name + ? updateNode(setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), ts.getEmitFlags(node)), node) + : node; + } + ts.updatePropertyAccessChain = updatePropertyAccessChain; + function createElementAccess(expression, index) { + var node = createSynthesizedNode(195); + node.expression = ts.parenthesizeForAccess(expression); + node.argumentExpression = asExpression(index); + return node; + } + ts.createElementAccess = createElementAccess; + function updateElementAccess(node, expression, argumentExpression) { + if (ts.isOptionalChain(node)) { + return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression); + } + return node.expression !== expression + || node.argumentExpression !== argumentExpression + ? updateNode(createElementAccess(expression, argumentExpression), node) + : node; + } + ts.updateElementAccess = updateElementAccess; + function createElementAccessChain(expression, questionDotToken, index) { + var node = createSynthesizedNode(195); + node.flags |= 32; + node.expression = ts.parenthesizeForAccess(expression); + node.questionDotToken = questionDotToken; + node.argumentExpression = asExpression(index); + return node; + } + ts.createElementAccessChain = createElementAccessChain; + function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) { + ts.Debug.assert(!!(node.flags & 32), "Cannot update an ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead."); + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.argumentExpression !== argumentExpression + ? updateNode(createElementAccessChain(expression, questionDotToken, argumentExpression), node) + : node; + } + ts.updateElementAccessChain = updateElementAccessChain; + function createCall(expression, typeArguments, argumentsArray) { + var node = createSynthesizedNode(196); + node.expression = ts.parenthesizeForAccess(expression); + node.typeArguments = asNodeArray(typeArguments); + node.arguments = ts.parenthesizeListElements(createNodeArray(argumentsArray)); + return node; + } + ts.createCall = createCall; + function updateCall(node, expression, typeArguments, argumentsArray) { + if (ts.isOptionalChain(node)) { + return updateCallChain(node, expression, node.questionDotToken, typeArguments, argumentsArray); + } + return node.expression !== expression + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? updateNode(createCall(expression, typeArguments, argumentsArray), node) + : node; + } + ts.updateCall = updateCall; + function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) { + var node = createSynthesizedNode(196); + node.flags |= 32; + node.expression = ts.parenthesizeForAccess(expression); + node.questionDotToken = questionDotToken; + node.typeArguments = asNodeArray(typeArguments); + node.arguments = ts.parenthesizeListElements(createNodeArray(argumentsArray)); + return node; + } + ts.createCallChain = createCallChain; + function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) { + ts.Debug.assert(!!(node.flags & 32), "Cannot update a CallExpression using updateCallChain. Use updateCall instead."); + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? updateNode(createCallChain(expression, questionDotToken, typeArguments, argumentsArray), node) + : node; + } + ts.updateCallChain = updateCallChain; + function createNew(expression, typeArguments, argumentsArray) { + var node = createSynthesizedNode(197); + node.expression = ts.parenthesizeForNew(expression); + node.typeArguments = asNodeArray(typeArguments); + node.arguments = argumentsArray ? ts.parenthesizeListElements(createNodeArray(argumentsArray)) : undefined; + return node; + } + ts.createNew = createNew; + function updateNew(node, expression, typeArguments, argumentsArray) { + return node.expression !== expression + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? updateNode(createNew(expression, typeArguments, argumentsArray), node) + : node; + } + ts.updateNew = updateNew; + function createTaggedTemplate(tag, typeArgumentsOrTemplate, template) { + var node = createSynthesizedNode(198); + node.tag = ts.parenthesizeForAccess(tag); + if (template) { + node.typeArguments = asNodeArray(typeArgumentsOrTemplate); + node.template = template; + } + else { + node.typeArguments = undefined; + node.template = typeArgumentsOrTemplate; + } + return node; + } + ts.createTaggedTemplate = createTaggedTemplate; + function updateTaggedTemplate(node, tag, typeArgumentsOrTemplate, template) { + return node.tag !== tag + || (template + ? node.typeArguments !== typeArgumentsOrTemplate || node.template !== template + : node.typeArguments !== undefined || node.template !== typeArgumentsOrTemplate) + ? updateNode(createTaggedTemplate(tag, typeArgumentsOrTemplate, template), node) + : node; + } + ts.updateTaggedTemplate = updateTaggedTemplate; + function createTypeAssertion(type, expression) { + var node = createSynthesizedNode(199); + node.type = type; + node.expression = ts.parenthesizePrefixOperand(expression); + return node; + } + ts.createTypeAssertion = createTypeAssertion; + function updateTypeAssertion(node, type, expression) { + return node.type !== type + || node.expression !== expression + ? updateNode(createTypeAssertion(type, expression), node) + : node; + } + ts.updateTypeAssertion = updateTypeAssertion; + function createParen(expression) { + var node = createSynthesizedNode(200); + node.expression = expression; + return node; + } + ts.createParen = createParen; + function updateParen(node, expression) { + return node.expression !== expression + ? updateNode(createParen(expression), node) + : node; + } + ts.updateParen = updateParen; + function createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + var node = createSynthesizedNode(201); + node.modifiers = asNodeArray(modifiers); + node.asteriskToken = asteriskToken; + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + node.body = body; + return node; + } + ts.createFunctionExpression = createFunctionExpression; + function updateFunctionExpression(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return node.name !== name + || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? updateNode(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) + : node; + } + ts.updateFunctionExpression = updateFunctionExpression; + function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) { + var node = createSynthesizedNode(202); + node.modifiers = asNodeArray(modifiers); + node.typeParameters = asNodeArray(typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + node.equalsGreaterThanToken = equalsGreaterThanToken || createToken(38); + node.body = ts.parenthesizeConciseBody(body); + return node; + } + ts.createArrowFunction = createArrowFunction; + function updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) { + return node.modifiers !== modifiers + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.equalsGreaterThanToken !== equalsGreaterThanToken + || node.body !== body + ? updateNode(createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node) + : node; + } + ts.updateArrowFunction = updateArrowFunction; + function createDelete(expression) { + var node = createSynthesizedNode(203); + node.expression = ts.parenthesizePrefixOperand(expression); + return node; + } + ts.createDelete = createDelete; + function updateDelete(node, expression) { + return node.expression !== expression + ? updateNode(createDelete(expression), node) + : node; + } + ts.updateDelete = updateDelete; + function createTypeOf(expression) { + var node = createSynthesizedNode(204); + node.expression = ts.parenthesizePrefixOperand(expression); + return node; + } + ts.createTypeOf = createTypeOf; + function updateTypeOf(node, expression) { + return node.expression !== expression + ? updateNode(createTypeOf(expression), node) + : node; + } + ts.updateTypeOf = updateTypeOf; + function createVoid(expression) { + var node = createSynthesizedNode(205); + node.expression = ts.parenthesizePrefixOperand(expression); + return node; + } + ts.createVoid = createVoid; + function updateVoid(node, expression) { + return node.expression !== expression + ? updateNode(createVoid(expression), node) + : node; + } + ts.updateVoid = updateVoid; + function createAwait(expression) { + var node = createSynthesizedNode(206); + node.expression = ts.parenthesizePrefixOperand(expression); + return node; + } + ts.createAwait = createAwait; + function updateAwait(node, expression) { + return node.expression !== expression + ? updateNode(createAwait(expression), node) + : node; + } + ts.updateAwait = updateAwait; + function createPrefix(operator, operand) { + var node = createSynthesizedNode(207); + node.operator = operator; + node.operand = ts.parenthesizePrefixOperand(operand); + return node; + } + ts.createPrefix = createPrefix; + function updatePrefix(node, operand) { + return node.operand !== operand + ? updateNode(createPrefix(node.operator, operand), node) + : node; + } + ts.updatePrefix = updatePrefix; + function createPostfix(operand, operator) { + var node = createSynthesizedNode(208); + node.operand = ts.parenthesizePostfixOperand(operand); + node.operator = operator; + return node; + } + ts.createPostfix = createPostfix; + function updatePostfix(node, operand) { + return node.operand !== operand + ? updateNode(createPostfix(operand, node.operator), node) + : node; + } + ts.updatePostfix = updatePostfix; + function createBinary(left, operator, right) { + var node = createSynthesizedNode(209); + var operatorToken = asToken(operator); + var operatorKind = operatorToken.kind; + node.left = ts.parenthesizeBinaryOperand(operatorKind, left, true, undefined); + node.operatorToken = operatorToken; + node.right = ts.parenthesizeBinaryOperand(operatorKind, right, false, node.left); + return node; + } + ts.createBinary = createBinary; + function updateBinary(node, left, right, operator) { + return node.left !== left + || node.right !== right + ? updateNode(createBinary(left, operator || node.operatorToken, right), node) + : node; + } + ts.updateBinary = updateBinary; + function createConditional(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) { + var node = createSynthesizedNode(210); + node.condition = ts.parenthesizeForConditionalHead(condition); + node.questionToken = whenFalse ? questionTokenOrWhenTrue : createToken(57); + node.whenTrue = ts.parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenTrueOrWhenFalse : questionTokenOrWhenTrue); + node.colonToken = whenFalse ? colonToken : createToken(58); + node.whenFalse = ts.parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenFalse : whenTrueOrWhenFalse); + return node; + } + ts.createConditional = createConditional; + function updateConditional(node, condition, questionToken, whenTrue, colonToken, whenFalse) { + return node.condition !== condition + || node.questionToken !== questionToken + || node.whenTrue !== whenTrue + || node.colonToken !== colonToken + || node.whenFalse !== whenFalse + ? updateNode(createConditional(condition, questionToken, whenTrue, colonToken, whenFalse), node) + : node; + } + ts.updateConditional = updateConditional; + function createTemplateExpression(head, templateSpans) { + var node = createSynthesizedNode(211); + node.head = head; + node.templateSpans = createNodeArray(templateSpans); + return node; + } + ts.createTemplateExpression = createTemplateExpression; + function updateTemplateExpression(node, head, templateSpans) { + return node.head !== head + || node.templateSpans !== templateSpans + ? updateNode(createTemplateExpression(head, templateSpans), node) + : node; + } + ts.updateTemplateExpression = updateTemplateExpression; + var rawTextScanner; + var invalidValueSentinel = {}; + function getCookedText(kind, rawText) { + if (!rawTextScanner) { + rawTextScanner = ts.createScanner(99, false, 0); + } + switch (kind) { + case 14: + rawTextScanner.setText("`" + rawText + "`"); + break; + case 15: + rawTextScanner.setText("`" + rawText + "${"); + break; + case 16: + rawTextScanner.setText("}" + rawText + "${"); + break; + case 17: + rawTextScanner.setText("}" + rawText + "`"); + break; + } + var token = rawTextScanner.scan(); + if (token === 23) { + token = rawTextScanner.reScanTemplateToken(); + } + if (rawTextScanner.isUnterminated()) { + rawTextScanner.setText(undefined); + return invalidValueSentinel; + } + var tokenValue; + switch (token) { + case 14: + case 15: + case 16: + case 17: + tokenValue = rawTextScanner.getTokenValue(); + break; + } + if (rawTextScanner.scan() !== 1) { + rawTextScanner.setText(undefined); + return invalidValueSentinel; + } + rawTextScanner.setText(undefined); + return tokenValue; + } + function createTemplateLiteralLikeNode(kind, text, rawText) { + var node = createSynthesizedNode(kind); + node.text = text; + if (rawText === undefined || text === rawText) { + node.rawText = rawText; + } + else { + var cooked = getCookedText(kind, rawText); + if (typeof cooked === "object") { + return ts.Debug.fail("Invalid raw text"); + } + ts.Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'."); + node.rawText = rawText; + } + return node; + } + function createTemplateHead(text, rawText) { + var node = createTemplateLiteralLikeNode(15, text, rawText); + node.text = text; + return node; + } + ts.createTemplateHead = createTemplateHead; + function createTemplateMiddle(text, rawText) { + var node = createTemplateLiteralLikeNode(16, text, rawText); + node.text = text; + return node; + } + ts.createTemplateMiddle = createTemplateMiddle; + function createTemplateTail(text, rawText) { + var node = createTemplateLiteralLikeNode(17, text, rawText); + node.text = text; + return node; + } + ts.createTemplateTail = createTemplateTail; + function createNoSubstitutionTemplateLiteral(text, rawText) { + var node = createTemplateLiteralLikeNode(14, text, rawText); + return node; + } + ts.createNoSubstitutionTemplateLiteral = createNoSubstitutionTemplateLiteral; + function createYield(asteriskTokenOrExpression, expression) { + var node = createSynthesizedNode(212); + node.asteriskToken = asteriskTokenOrExpression && asteriskTokenOrExpression.kind === 41 ? asteriskTokenOrExpression : undefined; + node.expression = asteriskTokenOrExpression && asteriskTokenOrExpression.kind !== 41 ? asteriskTokenOrExpression : expression; + return node; + } + ts.createYield = createYield; + function updateYield(node, asteriskToken, expression) { + return node.expression !== expression + || node.asteriskToken !== asteriskToken + ? updateNode(createYield(asteriskToken, expression), node) + : node; + } + ts.updateYield = updateYield; + function createSpread(expression) { + var node = createSynthesizedNode(213); + node.expression = ts.parenthesizeExpressionForList(expression); + return node; + } + ts.createSpread = createSpread; + function updateSpread(node, expression) { + return node.expression !== expression + ? updateNode(createSpread(expression), node) + : node; + } + ts.updateSpread = updateSpread; + function createClassExpression(modifiers, name, typeParameters, heritageClauses, members) { + var node = createSynthesizedNode(214); + node.decorators = undefined; + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.heritageClauses = asNodeArray(heritageClauses); + node.members = createNodeArray(members); + return node; + } + ts.createClassExpression = createClassExpression; + function updateClassExpression(node, modifiers, name, typeParameters, heritageClauses, members) { + return node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? updateNode(createClassExpression(modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + ts.updateClassExpression = updateClassExpression; + function createOmittedExpression() { + return createSynthesizedNode(215); + } + ts.createOmittedExpression = createOmittedExpression; + function createExpressionWithTypeArguments(typeArguments, expression) { + var node = createSynthesizedNode(216); + node.expression = ts.parenthesizeForAccess(expression); + node.typeArguments = asNodeArray(typeArguments); + return node; + } + ts.createExpressionWithTypeArguments = createExpressionWithTypeArguments; + function updateExpressionWithTypeArguments(node, typeArguments, expression) { + return node.typeArguments !== typeArguments + || node.expression !== expression + ? updateNode(createExpressionWithTypeArguments(typeArguments, expression), node) + : node; + } + ts.updateExpressionWithTypeArguments = updateExpressionWithTypeArguments; + function createAsExpression(expression, type) { + var node = createSynthesizedNode(217); + node.expression = expression; + node.type = type; + return node; + } + ts.createAsExpression = createAsExpression; + function updateAsExpression(node, expression, type) { + return node.expression !== expression + || node.type !== type + ? updateNode(createAsExpression(expression, type), node) + : node; + } + ts.updateAsExpression = updateAsExpression; + function createNonNullExpression(expression) { + var node = createSynthesizedNode(218); + node.expression = ts.parenthesizeForAccess(expression); + return node; + } + ts.createNonNullExpression = createNonNullExpression; + function updateNonNullExpression(node, expression) { + return node.expression !== expression + ? updateNode(createNonNullExpression(expression), node) + : node; + } + ts.updateNonNullExpression = updateNonNullExpression; + function createMetaProperty(keywordToken, name) { + var node = createSynthesizedNode(219); + node.keywordToken = keywordToken; + node.name = name; + return node; + } + ts.createMetaProperty = createMetaProperty; + function updateMetaProperty(node, name) { + return node.name !== name + ? updateNode(createMetaProperty(node.keywordToken, name), node) + : node; + } + ts.updateMetaProperty = updateMetaProperty; + function createTemplateSpan(expression, literal) { + var node = createSynthesizedNode(221); + node.expression = expression; + node.literal = literal; + return node; + } + ts.createTemplateSpan = createTemplateSpan; + function updateTemplateSpan(node, expression, literal) { + return node.expression !== expression + || node.literal !== literal + ? updateNode(createTemplateSpan(expression, literal), node) + : node; + } + ts.updateTemplateSpan = updateTemplateSpan; + function createSemicolonClassElement() { + return createSynthesizedNode(222); + } + ts.createSemicolonClassElement = createSemicolonClassElement; + function createBlock(statements, multiLine) { + var block = createSynthesizedNode(223); + block.statements = createNodeArray(statements); + if (multiLine) + block.multiLine = multiLine; + return block; + } + ts.createBlock = createBlock; + function updateBlock(node, statements) { + return node.statements !== statements + ? updateNode(createBlock(statements, node.multiLine), node) + : node; + } + ts.updateBlock = updateBlock; + function createVariableStatement(modifiers, declarationList) { + var node = createSynthesizedNode(225); + node.decorators = undefined; + node.modifiers = asNodeArray(modifiers); + node.declarationList = ts.isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList; + return node; + } + ts.createVariableStatement = createVariableStatement; + function updateVariableStatement(node, modifiers, declarationList) { + return node.modifiers !== modifiers + || node.declarationList !== declarationList + ? updateNode(createVariableStatement(modifiers, declarationList), node) + : node; + } + ts.updateVariableStatement = updateVariableStatement; + function createEmptyStatement() { + return createSynthesizedNode(224); + } + ts.createEmptyStatement = createEmptyStatement; + function createExpressionStatement(expression) { + var node = createSynthesizedNode(226); + node.expression = ts.parenthesizeExpressionForExpressionStatement(expression); + return node; + } + ts.createExpressionStatement = createExpressionStatement; + function updateExpressionStatement(node, expression) { + return node.expression !== expression + ? updateNode(createExpressionStatement(expression), node) + : node; + } + ts.updateExpressionStatement = updateExpressionStatement; + ts.createStatement = createExpressionStatement; + ts.updateStatement = updateExpressionStatement; + function createIf(expression, thenStatement, elseStatement) { + var node = createSynthesizedNode(227); + node.expression = expression; + node.thenStatement = asEmbeddedStatement(thenStatement); + node.elseStatement = asEmbeddedStatement(elseStatement); + return node; + } + ts.createIf = createIf; + function updateIf(node, expression, thenStatement, elseStatement) { + return node.expression !== expression + || node.thenStatement !== thenStatement + || node.elseStatement !== elseStatement + ? updateNode(createIf(expression, thenStatement, elseStatement), node) + : node; + } + ts.updateIf = updateIf; + function createDo(statement, expression) { + var node = createSynthesizedNode(228); + node.statement = asEmbeddedStatement(statement); + node.expression = expression; + return node; + } + ts.createDo = createDo; + function updateDo(node, statement, expression) { + return node.statement !== statement + || node.expression !== expression + ? updateNode(createDo(statement, expression), node) + : node; + } + ts.updateDo = updateDo; + function createWhile(expression, statement) { + var node = createSynthesizedNode(229); + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createWhile = createWhile; + function updateWhile(node, expression, statement) { + return node.expression !== expression + || node.statement !== statement + ? updateNode(createWhile(expression, statement), node) + : node; + } + ts.updateWhile = updateWhile; + function createFor(initializer, condition, incrementor, statement) { + var node = createSynthesizedNode(230); + node.initializer = initializer; + node.condition = condition; + node.incrementor = incrementor; + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createFor = createFor; + function updateFor(node, initializer, condition, incrementor, statement) { + return node.initializer !== initializer + || node.condition !== condition + || node.incrementor !== incrementor + || node.statement !== statement + ? updateNode(createFor(initializer, condition, incrementor, statement), node) + : node; + } + ts.updateFor = updateFor; + function createForIn(initializer, expression, statement) { + var node = createSynthesizedNode(231); + node.initializer = initializer; + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createForIn = createForIn; + function updateForIn(node, initializer, expression, statement) { + return node.initializer !== initializer + || node.expression !== expression + || node.statement !== statement + ? updateNode(createForIn(initializer, expression, statement), node) + : node; + } + ts.updateForIn = updateForIn; + function createForOf(awaitModifier, initializer, expression, statement) { + var node = createSynthesizedNode(232); + node.awaitModifier = awaitModifier; + node.initializer = initializer; + node.expression = ts.isCommaSequence(expression) ? createParen(expression) : expression; + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createForOf = createForOf; + function updateForOf(node, awaitModifier, initializer, expression, statement) { + return node.awaitModifier !== awaitModifier + || node.initializer !== initializer + || node.expression !== expression + || node.statement !== statement + ? updateNode(createForOf(awaitModifier, initializer, expression, statement), node) + : node; + } + ts.updateForOf = updateForOf; + function createContinue(label) { + var node = createSynthesizedNode(233); + node.label = asName(label); + return node; + } + ts.createContinue = createContinue; + function updateContinue(node, label) { + return node.label !== label + ? updateNode(createContinue(label), node) + : node; + } + ts.updateContinue = updateContinue; + function createBreak(label) { + var node = createSynthesizedNode(234); + node.label = asName(label); + return node; + } + ts.createBreak = createBreak; + function updateBreak(node, label) { + return node.label !== label + ? updateNode(createBreak(label), node) + : node; + } + ts.updateBreak = updateBreak; + function createReturn(expression) { + var node = createSynthesizedNode(235); + node.expression = expression; + return node; + } + ts.createReturn = createReturn; + function updateReturn(node, expression) { + return node.expression !== expression + ? updateNode(createReturn(expression), node) + : node; + } + ts.updateReturn = updateReturn; + function createWith(expression, statement) { + var node = createSynthesizedNode(236); + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createWith = createWith; + function updateWith(node, expression, statement) { + return node.expression !== expression + || node.statement !== statement + ? updateNode(createWith(expression, statement), node) + : node; + } + ts.updateWith = updateWith; + function createSwitch(expression, caseBlock) { + var node = createSynthesizedNode(237); + node.expression = ts.parenthesizeExpressionForList(expression); + node.caseBlock = caseBlock; + return node; + } + ts.createSwitch = createSwitch; + function updateSwitch(node, expression, caseBlock) { + return node.expression !== expression + || node.caseBlock !== caseBlock + ? updateNode(createSwitch(expression, caseBlock), node) + : node; + } + ts.updateSwitch = updateSwitch; + function createLabel(label, statement) { + var node = createSynthesizedNode(238); + node.label = asName(label); + node.statement = asEmbeddedStatement(statement); + return node; + } + ts.createLabel = createLabel; + function updateLabel(node, label, statement) { + return node.label !== label + || node.statement !== statement + ? updateNode(createLabel(label, statement), node) + : node; + } + ts.updateLabel = updateLabel; + function createThrow(expression) { + var node = createSynthesizedNode(239); + node.expression = expression; + return node; + } + ts.createThrow = createThrow; + function updateThrow(node, expression) { + return node.expression !== expression + ? updateNode(createThrow(expression), node) + : node; + } + ts.updateThrow = updateThrow; + function createTry(tryBlock, catchClause, finallyBlock) { + var node = createSynthesizedNode(240); + node.tryBlock = tryBlock; + node.catchClause = catchClause; + node.finallyBlock = finallyBlock; + return node; + } + ts.createTry = createTry; + function updateTry(node, tryBlock, catchClause, finallyBlock) { + return node.tryBlock !== tryBlock + || node.catchClause !== catchClause + || node.finallyBlock !== finallyBlock + ? updateNode(createTry(tryBlock, catchClause, finallyBlock), node) + : node; + } + ts.updateTry = updateTry; + function createDebuggerStatement() { + return createSynthesizedNode(241); + } + ts.createDebuggerStatement = createDebuggerStatement; + function createVariableDeclaration(name, type, initializer) { + var node = createSynthesizedNode(242); + node.name = asName(name); + node.type = type; + node.initializer = initializer !== undefined ? ts.parenthesizeExpressionForList(initializer) : undefined; + return node; + } + ts.createVariableDeclaration = createVariableDeclaration; + function updateVariableDeclaration(node, name, type, initializer) { + return node.name !== name + || node.type !== type + || node.initializer !== initializer + ? updateNode(createVariableDeclaration(name, type, initializer), node) + : node; + } + ts.updateVariableDeclaration = updateVariableDeclaration; + function createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer) { + var node = createSynthesizedNode(242); + node.name = asName(name); + node.type = type; + node.initializer = initializer !== undefined ? ts.parenthesizeExpressionForList(initializer) : undefined; + node.exclamationToken = exclaimationToken; + return node; + } + ts.createTypeScriptVariableDeclaration = createTypeScriptVariableDeclaration; + function updateTypeScriptVariableDeclaration(node, name, exclaimationToken, type, initializer) { + return node.name !== name + || node.type !== type + || node.initializer !== initializer + || node.exclamationToken !== exclaimationToken + ? updateNode(createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer), node) + : node; + } + ts.updateTypeScriptVariableDeclaration = updateTypeScriptVariableDeclaration; + function createVariableDeclarationList(declarations, flags) { + if (flags === void 0) { flags = 0; } + var node = createSynthesizedNode(243); + node.flags |= flags & 3; + node.declarations = createNodeArray(declarations); + return node; + } + ts.createVariableDeclarationList = createVariableDeclarationList; + function updateVariableDeclarationList(node, declarations) { + return node.declarations !== declarations + ? updateNode(createVariableDeclarationList(declarations, node.flags), node) + : node; + } + ts.updateVariableDeclarationList = updateVariableDeclarationList; + function createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + var node = createSynthesizedNode(244); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.asteriskToken = asteriskToken; + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + node.body = body; + return node; + } + ts.createFunctionDeclaration = createFunctionDeclaration; + function updateFunctionDeclaration(node, decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.name !== name + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? updateNode(createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) + : node; + } + ts.updateFunctionDeclaration = updateFunctionDeclaration; + function createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) { + var node = createSynthesizedNode(245); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.heritageClauses = asNodeArray(heritageClauses); + node.members = createNodeArray(members); + return node; + } + ts.createClassDeclaration = createClassDeclaration; + function updateClassDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? updateNode(createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + ts.updateClassDeclaration = updateClassDeclaration; + function createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) { + var node = createSynthesizedNode(246); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.heritageClauses = asNodeArray(heritageClauses); + node.members = createNodeArray(members); + return node; + } + ts.createInterfaceDeclaration = createInterfaceDeclaration; + function updateInterfaceDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? updateNode(createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + ts.updateInterfaceDeclaration = updateInterfaceDeclaration; + function createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type) { + var node = createSynthesizedNode(247); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.typeParameters = asNodeArray(typeParameters); + node.type = type; + return node; + } + ts.createTypeAliasDeclaration = createTypeAliasDeclaration; + function updateTypeAliasDeclaration(node, decorators, modifiers, name, typeParameters, type) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.type !== type + ? updateNode(createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type), node) + : node; + } + ts.updateTypeAliasDeclaration = updateTypeAliasDeclaration; + function createEnumDeclaration(decorators, modifiers, name, members) { + var node = createSynthesizedNode(248); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.members = createNodeArray(members); + return node; + } + ts.createEnumDeclaration = createEnumDeclaration; + function updateEnumDeclaration(node, decorators, modifiers, name, members) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.members !== members + ? updateNode(createEnumDeclaration(decorators, modifiers, name, members), node) + : node; + } + ts.updateEnumDeclaration = updateEnumDeclaration; + function createModuleDeclaration(decorators, modifiers, name, body, flags) { + if (flags === void 0) { flags = 0; } + var node = createSynthesizedNode(249); + node.flags |= flags & (16 | 4 | 1024); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = name; + node.body = body; + return node; + } + ts.createModuleDeclaration = createModuleDeclaration; + function updateModuleDeclaration(node, decorators, modifiers, name, body) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.body !== body + ? updateNode(createModuleDeclaration(decorators, modifiers, name, body, node.flags), node) + : node; + } + ts.updateModuleDeclaration = updateModuleDeclaration; + function createModuleBlock(statements) { + var node = createSynthesizedNode(250); + node.statements = createNodeArray(statements); + return node; + } + ts.createModuleBlock = createModuleBlock; + function updateModuleBlock(node, statements) { + return node.statements !== statements + ? updateNode(createModuleBlock(statements), node) + : node; + } + ts.updateModuleBlock = updateModuleBlock; + function createCaseBlock(clauses) { + var node = createSynthesizedNode(251); + node.clauses = createNodeArray(clauses); + return node; + } + ts.createCaseBlock = createCaseBlock; + function updateCaseBlock(node, clauses) { + return node.clauses !== clauses + ? updateNode(createCaseBlock(clauses), node) + : node; + } + ts.updateCaseBlock = updateCaseBlock; + function createNamespaceExportDeclaration(name) { + var node = createSynthesizedNode(252); + node.name = asName(name); + return node; + } + ts.createNamespaceExportDeclaration = createNamespaceExportDeclaration; + function updateNamespaceExportDeclaration(node, name) { + return node.name !== name + ? updateNode(createNamespaceExportDeclaration(name), node) + : node; + } + ts.updateNamespaceExportDeclaration = updateNamespaceExportDeclaration; + function createImportEqualsDeclaration(decorators, modifiers, name, moduleReference) { + var node = createSynthesizedNode(253); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.name = asName(name); + node.moduleReference = moduleReference; + return node; + } + ts.createImportEqualsDeclaration = createImportEqualsDeclaration; + function updateImportEqualsDeclaration(node, decorators, modifiers, name, moduleReference) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.name !== name + || node.moduleReference !== moduleReference + ? updateNode(createImportEqualsDeclaration(decorators, modifiers, name, moduleReference), node) + : node; + } + ts.updateImportEqualsDeclaration = updateImportEqualsDeclaration; + function createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier) { + var node = createSynthesizedNode(254); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.importClause = importClause; + node.moduleSpecifier = moduleSpecifier; + return node; + } + ts.createImportDeclaration = createImportDeclaration; + function updateImportDeclaration(node, decorators, modifiers, importClause, moduleSpecifier) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.importClause !== importClause + || node.moduleSpecifier !== moduleSpecifier + ? updateNode(createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier), node) + : node; + } + ts.updateImportDeclaration = updateImportDeclaration; + function createImportClause(name, namedBindings, isTypeOnly) { + if (isTypeOnly === void 0) { isTypeOnly = false; } + var node = createSynthesizedNode(255); + node.name = name; + node.namedBindings = namedBindings; + node.isTypeOnly = isTypeOnly; + return node; + } + ts.createImportClause = createImportClause; + function updateImportClause(node, name, namedBindings, isTypeOnly) { + return node.name !== name + || node.namedBindings !== namedBindings + || node.isTypeOnly !== isTypeOnly + ? updateNode(createImportClause(name, namedBindings, isTypeOnly), node) + : node; + } + ts.updateImportClause = updateImportClause; + function createNamespaceImport(name) { + var node = createSynthesizedNode(256); + node.name = name; + return node; + } + ts.createNamespaceImport = createNamespaceImport; + function createNamespaceExport(name) { + var node = createSynthesizedNode(262); + node.name = name; + return node; + } + ts.createNamespaceExport = createNamespaceExport; + function updateNamespaceImport(node, name) { + return node.name !== name + ? updateNode(createNamespaceImport(name), node) + : node; + } + ts.updateNamespaceImport = updateNamespaceImport; + function updateNamespaceExport(node, name) { + return node.name !== name + ? updateNode(createNamespaceExport(name), node) + : node; + } + ts.updateNamespaceExport = updateNamespaceExport; + function createNamedImports(elements) { + var node = createSynthesizedNode(257); + node.elements = createNodeArray(elements); + return node; + } + ts.createNamedImports = createNamedImports; + function updateNamedImports(node, elements) { + return node.elements !== elements + ? updateNode(createNamedImports(elements), node) + : node; + } + ts.updateNamedImports = updateNamedImports; + function createImportSpecifier(propertyName, name) { + var node = createSynthesizedNode(258); + node.propertyName = propertyName; + node.name = name; + return node; + } + ts.createImportSpecifier = createImportSpecifier; + function updateImportSpecifier(node, propertyName, name) { + return node.propertyName !== propertyName + || node.name !== name + ? updateNode(createImportSpecifier(propertyName, name), node) + : node; + } + ts.updateImportSpecifier = updateImportSpecifier; + function createExportAssignment(decorators, modifiers, isExportEquals, expression) { + var node = createSynthesizedNode(259); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.isExportEquals = isExportEquals; + node.expression = isExportEquals ? ts.parenthesizeBinaryOperand(62, expression, false, undefined) : ts.parenthesizeDefaultExpression(expression); + return node; + } + ts.createExportAssignment = createExportAssignment; + function updateExportAssignment(node, decorators, modifiers, expression) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.expression !== expression + ? updateNode(createExportAssignment(decorators, modifiers, node.isExportEquals, expression), node) + : node; + } + ts.updateExportAssignment = updateExportAssignment; + function createExportDeclaration(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) { + if (isTypeOnly === void 0) { isTypeOnly = false; } + var node = createSynthesizedNode(260); + node.decorators = asNodeArray(decorators); + node.modifiers = asNodeArray(modifiers); + node.isTypeOnly = isTypeOnly; + node.exportClause = exportClause; + node.moduleSpecifier = moduleSpecifier; + return node; + } + ts.createExportDeclaration = createExportDeclaration; + function updateExportDeclaration(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) { + return node.decorators !== decorators + || node.modifiers !== modifiers + || node.isTypeOnly !== isTypeOnly + || node.exportClause !== exportClause + || node.moduleSpecifier !== moduleSpecifier + ? updateNode(createExportDeclaration(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly), node) + : node; + } + ts.updateExportDeclaration = updateExportDeclaration; + function createEmptyExports() { + return createExportDeclaration(undefined, undefined, createNamedExports([]), undefined); + } + ts.createEmptyExports = createEmptyExports; + function createNamedExports(elements) { + var node = createSynthesizedNode(261); + node.elements = createNodeArray(elements); + return node; + } + ts.createNamedExports = createNamedExports; + function updateNamedExports(node, elements) { + return node.elements !== elements + ? updateNode(createNamedExports(elements), node) + : node; + } + ts.updateNamedExports = updateNamedExports; + function createExportSpecifier(propertyName, name) { + var node = createSynthesizedNode(263); + node.propertyName = asName(propertyName); + node.name = asName(name); + return node; + } + ts.createExportSpecifier = createExportSpecifier; + function updateExportSpecifier(node, propertyName, name) { + return node.propertyName !== propertyName + || node.name !== name + ? updateNode(createExportSpecifier(propertyName, name), node) + : node; + } + ts.updateExportSpecifier = updateExportSpecifier; + function createExternalModuleReference(expression) { + var node = createSynthesizedNode(265); + node.expression = expression; + return node; + } + ts.createExternalModuleReference = createExternalModuleReference; + function updateExternalModuleReference(node, expression) { + return node.expression !== expression + ? updateNode(createExternalModuleReference(expression), node) + : node; + } + ts.updateExternalModuleReference = updateExternalModuleReference; + function createJSDocTypeExpression(type) { + var node = createSynthesizedNode(294); + node.type = type; + return node; + } + ts.createJSDocTypeExpression = createJSDocTypeExpression; + function createJSDocTypeTag(typeExpression, comment) { + var tag = createJSDocTag(319, "type"); + tag.typeExpression = typeExpression; + tag.comment = comment; + return tag; + } + ts.createJSDocTypeTag = createJSDocTypeTag; + function createJSDocReturnTag(typeExpression, comment) { + var tag = createJSDocTag(317, "returns"); + tag.typeExpression = typeExpression; + tag.comment = comment; + return tag; + } + ts.createJSDocReturnTag = createJSDocReturnTag; + function createJSDocThisTag(typeExpression) { + var tag = createJSDocTag(318, "this"); + tag.typeExpression = typeExpression; + return tag; + } + ts.createJSDocThisTag = createJSDocThisTag; + function createJSDocParamTag(name, isBracketed, typeExpression, comment) { + var tag = createJSDocTag(316, "param"); + tag.typeExpression = typeExpression; + tag.name = name; + tag.isBracketed = isBracketed; + tag.comment = comment; + return tag; + } + ts.createJSDocParamTag = createJSDocParamTag; + function createJSDocComment(comment, tags) { + var node = createSynthesizedNode(303); + node.comment = comment; + node.tags = tags; + return node; + } + ts.createJSDocComment = createJSDocComment; + function createJSDocTag(kind, tagName) { + var node = createSynthesizedNode(kind); + node.tagName = createIdentifier(tagName); + return node; + } + function createJsxElement(openingElement, children, closingElement) { + var node = createSynthesizedNode(266); + node.openingElement = openingElement; + node.children = createNodeArray(children); + node.closingElement = closingElement; + return node; + } + ts.createJsxElement = createJsxElement; + function updateJsxElement(node, openingElement, children, closingElement) { + return node.openingElement !== openingElement + || node.children !== children + || node.closingElement !== closingElement + ? updateNode(createJsxElement(openingElement, children, closingElement), node) + : node; + } + ts.updateJsxElement = updateJsxElement; + function createJsxSelfClosingElement(tagName, typeArguments, attributes) { + var node = createSynthesizedNode(267); + node.tagName = tagName; + node.typeArguments = asNodeArray(typeArguments); + node.attributes = attributes; + return node; + } + ts.createJsxSelfClosingElement = createJsxSelfClosingElement; + function updateJsxSelfClosingElement(node, tagName, typeArguments, attributes) { + return node.tagName !== tagName + || node.typeArguments !== typeArguments + || node.attributes !== attributes + ? updateNode(createJsxSelfClosingElement(tagName, typeArguments, attributes), node) + : node; + } + ts.updateJsxSelfClosingElement = updateJsxSelfClosingElement; + function createJsxOpeningElement(tagName, typeArguments, attributes) { + var node = createSynthesizedNode(268); + node.tagName = tagName; + node.typeArguments = asNodeArray(typeArguments); + node.attributes = attributes; + return node; + } + ts.createJsxOpeningElement = createJsxOpeningElement; + function updateJsxOpeningElement(node, tagName, typeArguments, attributes) { + return node.tagName !== tagName + || node.typeArguments !== typeArguments + || node.attributes !== attributes + ? updateNode(createJsxOpeningElement(tagName, typeArguments, attributes), node) + : node; + } + ts.updateJsxOpeningElement = updateJsxOpeningElement; + function createJsxClosingElement(tagName) { + var node = createSynthesizedNode(269); + node.tagName = tagName; + return node; + } + ts.createJsxClosingElement = createJsxClosingElement; + function updateJsxClosingElement(node, tagName) { + return node.tagName !== tagName + ? updateNode(createJsxClosingElement(tagName), node) + : node; + } + ts.updateJsxClosingElement = updateJsxClosingElement; + function createJsxFragment(openingFragment, children, closingFragment) { + var node = createSynthesizedNode(270); + node.openingFragment = openingFragment; + node.children = createNodeArray(children); + node.closingFragment = closingFragment; + return node; + } + ts.createJsxFragment = createJsxFragment; + function createJsxText(text, containsOnlyTriviaWhiteSpaces) { + var node = createSynthesizedNode(11); + node.text = text; + node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces; + return node; + } + ts.createJsxText = createJsxText; + function updateJsxText(node, text, containsOnlyTriviaWhiteSpaces) { + return node.text !== text + || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces + ? updateNode(createJsxText(text, containsOnlyTriviaWhiteSpaces), node) + : node; + } + ts.updateJsxText = updateJsxText; + function createJsxOpeningFragment() { + return createSynthesizedNode(271); + } + ts.createJsxOpeningFragment = createJsxOpeningFragment; + function createJsxJsxClosingFragment() { + return createSynthesizedNode(272); + } + ts.createJsxJsxClosingFragment = createJsxJsxClosingFragment; + function updateJsxFragment(node, openingFragment, children, closingFragment) { + return node.openingFragment !== openingFragment + || node.children !== children + || node.closingFragment !== closingFragment + ? updateNode(createJsxFragment(openingFragment, children, closingFragment), node) + : node; + } + ts.updateJsxFragment = updateJsxFragment; + function createJsxAttribute(name, initializer) { + var node = createSynthesizedNode(273); + node.name = name; + node.initializer = initializer; + return node; + } + ts.createJsxAttribute = createJsxAttribute; + function updateJsxAttribute(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? updateNode(createJsxAttribute(name, initializer), node) + : node; + } + ts.updateJsxAttribute = updateJsxAttribute; + function createJsxAttributes(properties) { + var node = createSynthesizedNode(274); + node.properties = createNodeArray(properties); + return node; + } + ts.createJsxAttributes = createJsxAttributes; + function updateJsxAttributes(node, properties) { + return node.properties !== properties + ? updateNode(createJsxAttributes(properties), node) + : node; + } + ts.updateJsxAttributes = updateJsxAttributes; + function createJsxSpreadAttribute(expression) { + var node = createSynthesizedNode(275); + node.expression = expression; + return node; + } + ts.createJsxSpreadAttribute = createJsxSpreadAttribute; + function updateJsxSpreadAttribute(node, expression) { + return node.expression !== expression + ? updateNode(createJsxSpreadAttribute(expression), node) + : node; + } + ts.updateJsxSpreadAttribute = updateJsxSpreadAttribute; + function createJsxExpression(dotDotDotToken, expression) { + var node = createSynthesizedNode(276); + node.dotDotDotToken = dotDotDotToken; + node.expression = expression; + return node; + } + ts.createJsxExpression = createJsxExpression; + function updateJsxExpression(node, expression) { + return node.expression !== expression + ? updateNode(createJsxExpression(node.dotDotDotToken, expression), node) + : node; + } + ts.updateJsxExpression = updateJsxExpression; + function createCaseClause(expression, statements) { + var node = createSynthesizedNode(277); + node.expression = ts.parenthesizeExpressionForList(expression); + node.statements = createNodeArray(statements); + return node; + } + ts.createCaseClause = createCaseClause; + function updateCaseClause(node, expression, statements) { + return node.expression !== expression + || node.statements !== statements + ? updateNode(createCaseClause(expression, statements), node) + : node; + } + ts.updateCaseClause = updateCaseClause; + function createDefaultClause(statements) { + var node = createSynthesizedNode(278); + node.statements = createNodeArray(statements); + return node; + } + ts.createDefaultClause = createDefaultClause; + function updateDefaultClause(node, statements) { + return node.statements !== statements + ? updateNode(createDefaultClause(statements), node) + : node; + } + ts.updateDefaultClause = updateDefaultClause; + function createHeritageClause(token, types) { + var node = createSynthesizedNode(279); + node.token = token; + node.types = createNodeArray(types); + return node; + } + ts.createHeritageClause = createHeritageClause; + function updateHeritageClause(node, types) { + return node.types !== types + ? updateNode(createHeritageClause(node.token, types), node) + : node; + } + ts.updateHeritageClause = updateHeritageClause; + function createCatchClause(variableDeclaration, block) { + var node = createSynthesizedNode(280); + node.variableDeclaration = ts.isString(variableDeclaration) ? createVariableDeclaration(variableDeclaration) : variableDeclaration; + node.block = block; + return node; + } + ts.createCatchClause = createCatchClause; + function updateCatchClause(node, variableDeclaration, block) { + return node.variableDeclaration !== variableDeclaration + || node.block !== block + ? updateNode(createCatchClause(variableDeclaration, block), node) + : node; + } + ts.updateCatchClause = updateCatchClause; + function createPropertyAssignment(name, initializer) { + var node = createSynthesizedNode(281); + node.name = asName(name); + node.questionToken = undefined; + node.initializer = ts.parenthesizeExpressionForList(initializer); + return node; + } + ts.createPropertyAssignment = createPropertyAssignment; + function updatePropertyAssignment(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? updateNode(createPropertyAssignment(name, initializer), node) + : node; + } + ts.updatePropertyAssignment = updatePropertyAssignment; + function createShorthandPropertyAssignment(name, objectAssignmentInitializer) { + var node = createSynthesizedNode(282); + node.name = asName(name); + node.objectAssignmentInitializer = objectAssignmentInitializer !== undefined ? ts.parenthesizeExpressionForList(objectAssignmentInitializer) : undefined; + return node; + } + ts.createShorthandPropertyAssignment = createShorthandPropertyAssignment; + function updateShorthandPropertyAssignment(node, name, objectAssignmentInitializer) { + return node.name !== name + || node.objectAssignmentInitializer !== objectAssignmentInitializer + ? updateNode(createShorthandPropertyAssignment(name, objectAssignmentInitializer), node) + : node; + } + ts.updateShorthandPropertyAssignment = updateShorthandPropertyAssignment; + function createSpreadAssignment(expression) { + var node = createSynthesizedNode(283); + node.expression = ts.parenthesizeExpressionForList(expression); + return node; + } + ts.createSpreadAssignment = createSpreadAssignment; + function updateSpreadAssignment(node, expression) { + return node.expression !== expression + ? updateNode(createSpreadAssignment(expression), node) + : node; + } + ts.updateSpreadAssignment = updateSpreadAssignment; + function createEnumMember(name, initializer) { + var node = createSynthesizedNode(284); + node.name = asName(name); + node.initializer = initializer && ts.parenthesizeExpressionForList(initializer); + return node; + } + ts.createEnumMember = createEnumMember; + function updateEnumMember(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? updateNode(createEnumMember(name, initializer), node) + : node; + } + ts.updateEnumMember = updateEnumMember; + function updateSourceFileNode(node, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) { + if (node.statements !== statements || + (isDeclarationFile !== undefined && node.isDeclarationFile !== isDeclarationFile) || + (referencedFiles !== undefined && node.referencedFiles !== referencedFiles) || + (typeReferences !== undefined && node.typeReferenceDirectives !== typeReferences) || + (libReferences !== undefined && node.libReferenceDirectives !== libReferences) || + (hasNoDefaultLib !== undefined && node.hasNoDefaultLib !== hasNoDefaultLib)) { + var updated = createSynthesizedNode(290); + updated.flags |= node.flags; + updated.statements = createNodeArray(statements); + updated.endOfFileToken = node.endOfFileToken; + updated.fileName = node.fileName; + updated.path = node.path; + updated.text = node.text; + updated.isDeclarationFile = isDeclarationFile === undefined ? node.isDeclarationFile : isDeclarationFile; + updated.referencedFiles = referencedFiles === undefined ? node.referencedFiles : referencedFiles; + updated.typeReferenceDirectives = typeReferences === undefined ? node.typeReferenceDirectives : typeReferences; + updated.hasNoDefaultLib = hasNoDefaultLib === undefined ? node.hasNoDefaultLib : hasNoDefaultLib; + updated.libReferenceDirectives = libReferences === undefined ? node.libReferenceDirectives : libReferences; + if (node.amdDependencies !== undefined) + updated.amdDependencies = node.amdDependencies; + if (node.moduleName !== undefined) + updated.moduleName = node.moduleName; + if (node.languageVariant !== undefined) + updated.languageVariant = node.languageVariant; + if (node.renamedDependencies !== undefined) + updated.renamedDependencies = node.renamedDependencies; + if (node.languageVersion !== undefined) + updated.languageVersion = node.languageVersion; + if (node.scriptKind !== undefined) + updated.scriptKind = node.scriptKind; + if (node.externalModuleIndicator !== undefined) + updated.externalModuleIndicator = node.externalModuleIndicator; + if (node.commonJsModuleIndicator !== undefined) + updated.commonJsModuleIndicator = node.commonJsModuleIndicator; + if (node.identifiers !== undefined) + updated.identifiers = node.identifiers; + if (node.nodeCount !== undefined) + updated.nodeCount = node.nodeCount; + if (node.identifierCount !== undefined) + updated.identifierCount = node.identifierCount; + if (node.symbolCount !== undefined) + updated.symbolCount = node.symbolCount; + if (node.parseDiagnostics !== undefined) + updated.parseDiagnostics = node.parseDiagnostics; + if (node.bindDiagnostics !== undefined) + updated.bindDiagnostics = node.bindDiagnostics; + if (node.bindSuggestionDiagnostics !== undefined) + updated.bindSuggestionDiagnostics = node.bindSuggestionDiagnostics; + if (node.lineMap !== undefined) + updated.lineMap = node.lineMap; + if (node.classifiableNames !== undefined) + updated.classifiableNames = node.classifiableNames; + if (node.resolvedModules !== undefined) + updated.resolvedModules = node.resolvedModules; + if (node.resolvedTypeReferenceDirectiveNames !== undefined) + updated.resolvedTypeReferenceDirectiveNames = node.resolvedTypeReferenceDirectiveNames; + if (node.imports !== undefined) + updated.imports = node.imports; + if (node.moduleAugmentations !== undefined) + updated.moduleAugmentations = node.moduleAugmentations; + if (node.pragmas !== undefined) + updated.pragmas = node.pragmas; + if (node.localJsxFactory !== undefined) + updated.localJsxFactory = node.localJsxFactory; + if (node.localJsxNamespace !== undefined) + updated.localJsxNamespace = node.localJsxNamespace; + return updateNode(updated, node); + } + return node; + } + ts.updateSourceFileNode = updateSourceFileNode; + function getMutableClone(node) { + var clone = getSynthesizedClone(node); + clone.pos = node.pos; + clone.end = node.end; + clone.parent = node.parent; + return clone; + } + ts.getMutableClone = getMutableClone; + function createNotEmittedStatement(original) { + var node = createSynthesizedNode(324); + node.original = original; + setTextRange(node, original); + return node; + } + ts.createNotEmittedStatement = createNotEmittedStatement; + function createEndOfDeclarationMarker(original) { + var node = createSynthesizedNode(328); + node.emitNode = {}; + node.original = original; + return node; + } + ts.createEndOfDeclarationMarker = createEndOfDeclarationMarker; + function createMergeDeclarationMarker(original) { + var node = createSynthesizedNode(327); + node.emitNode = {}; + node.original = original; + return node; + } + ts.createMergeDeclarationMarker = createMergeDeclarationMarker; + function createPartiallyEmittedExpression(expression, original) { + var node = createSynthesizedNode(325); + node.expression = expression; + node.original = original; + setTextRange(node, original); + return node; + } + ts.createPartiallyEmittedExpression = createPartiallyEmittedExpression; + function updatePartiallyEmittedExpression(node, expression) { + if (node.expression !== expression) { + return updateNode(createPartiallyEmittedExpression(expression, node.original), node); + } + return node; + } + ts.updatePartiallyEmittedExpression = updatePartiallyEmittedExpression; + function flattenCommaElements(node) { + if (ts.nodeIsSynthesized(node) && !ts.isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) { + if (node.kind === 326) { + return node.elements; + } + if (ts.isBinaryExpression(node) && node.operatorToken.kind === 27) { + return [node.left, node.right]; + } + } + return node; + } + function createCommaList(elements) { + var node = createSynthesizedNode(326); + node.elements = createNodeArray(ts.sameFlatMap(elements, flattenCommaElements)); + return node; + } + ts.createCommaList = createCommaList; + function updateCommaList(node, elements) { + return node.elements !== elements + ? updateNode(createCommaList(elements), node) + : node; + } + ts.updateCommaList = updateCommaList; + function createSyntheticReferenceExpression(expression, thisArg) { + var node = createSynthesizedNode(329); + node.expression = expression; + node.thisArg = thisArg; + return node; + } + ts.createSyntheticReferenceExpression = createSyntheticReferenceExpression; + function updateSyntheticReferenceExpression(node, expression, thisArg) { + return node.expression !== expression + || node.thisArg !== thisArg + ? updateNode(createSyntheticReferenceExpression(expression, thisArg), node) + : node; + } + ts.updateSyntheticReferenceExpression = updateSyntheticReferenceExpression; + function createBundle(sourceFiles, prepends) { + if (prepends === void 0) { prepends = ts.emptyArray; } + var node = ts.createNode(291); + node.prepends = prepends; + node.sourceFiles = sourceFiles; + return node; + } + ts.createBundle = createBundle; + var allUnscopedEmitHelpers; + function getAllUnscopedEmitHelpers() { + return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([ + ts.valuesHelper, + ts.readHelper, + ts.spreadHelper, + ts.spreadArraysHelper, + ts.restHelper, + ts.decorateHelper, + ts.metadataHelper, + ts.paramHelper, + ts.awaiterHelper, + ts.assignHelper, + ts.awaitHelper, + ts.asyncGeneratorHelper, + ts.asyncDelegator, + ts.asyncValues, + ts.extendsHelper, + ts.templateObjectHelper, + ts.generatorHelper, + ts.importStarHelper, + ts.importDefaultHelper, + ts.classPrivateFieldGetHelper, + ts.classPrivateFieldSetHelper, + ], function (helper) { return helper.name; })); + } + function createUnparsedSource() { + var node = ts.createNode(292); + node.prologues = ts.emptyArray; + node.referencedFiles = ts.emptyArray; + node.libReferenceDirectives = ts.emptyArray; + node.getLineAndCharacterOfPosition = function (pos) { return ts.getLineAndCharacterOfPosition(node, pos); }; + return node; + } + function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) { + var node = createUnparsedSource(); + var stripInternal; + var bundleFileInfo; + if (!ts.isString(textOrInputFiles)) { + ts.Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts"); + node.fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || ""; + node.sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath; + Object.defineProperties(node, { + text: { get: function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText; } }, + sourceMapText: { get: function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText; } }, + }); + if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) { + node.oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit; + ts.Debug.assert(mapTextOrStripInternal === undefined || typeof mapTextOrStripInternal === "boolean"); + stripInternal = mapTextOrStripInternal; + bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts; + if (node.oldFileOfCurrentEmit) { + parseOldFileOfCurrentEmit(node, ts.Debug.assertDefined(bundleFileInfo)); + return node; + } + } + } + else { + node.fileName = ""; + node.text = textOrInputFiles; + node.sourceMapPath = mapPathOrType; + node.sourceMapText = mapTextOrStripInternal; + } + ts.Debug.assert(!node.oldFileOfCurrentEmit); + parseUnparsedSourceFile(node, bundleFileInfo, stripInternal); + return node; + } + ts.createUnparsedSourceFile = createUnparsedSourceFile; + function parseUnparsedSourceFile(node, bundleFileInfo, stripInternal) { + var prologues; + var helpers; + var referencedFiles; + var typeReferenceDirectives; + var libReferenceDirectives; + var texts; + for (var _i = 0, _a = bundleFileInfo ? bundleFileInfo.sections : ts.emptyArray; _i < _a.length; _i++) { + var section = _a[_i]; + switch (section.kind) { + case "prologue": + (prologues || (prologues = [])).push(createUnparsedNode(section, node)); + break; + case "emitHelpers": + (helpers || (helpers = [])).push(getAllUnscopedEmitHelpers().get(section.data)); + break; + case "no-default-lib": + node.hasNoDefaultLib = true; + break; + case "reference": + (referencedFiles || (referencedFiles = [])).push({ pos: -1, end: -1, fileName: section.data }); + break; + case "type": + (typeReferenceDirectives || (typeReferenceDirectives = [])).push(section.data); + break; + case "lib": + (libReferenceDirectives || (libReferenceDirectives = [])).push({ pos: -1, end: -1, fileName: section.data }); + break; + case "prepend": + var prependNode = createUnparsedNode(section, node); + var prependTexts = void 0; + for (var _b = 0, _c = section.texts; _b < _c.length; _b++) { + var text = _c[_b]; + if (!stripInternal || text.kind !== "internal") { + (prependTexts || (prependTexts = [])).push(createUnparsedNode(text, node)); + } + } + prependNode.texts = prependTexts || ts.emptyArray; + (texts || (texts = [])).push(prependNode); + break; + case "internal": + if (stripInternal) { + if (!texts) + texts = []; + break; + } + case "text": + (texts || (texts = [])).push(createUnparsedNode(section, node)); + break; + default: + ts.Debug.assertNever(section); + } + } + node.prologues = prologues || ts.emptyArray; + node.helpers = helpers; + node.referencedFiles = referencedFiles || ts.emptyArray; + node.typeReferenceDirectives = typeReferenceDirectives; + node.libReferenceDirectives = libReferenceDirectives || ts.emptyArray; + node.texts = texts || [createUnparsedNode({ kind: "text", pos: 0, end: node.text.length }, node)]; + } + function parseOldFileOfCurrentEmit(node, bundleFileInfo) { + ts.Debug.assert(!!node.oldFileOfCurrentEmit); + var texts; + var syntheticReferences; + for (var _i = 0, _a = bundleFileInfo.sections; _i < _a.length; _i++) { + var section = _a[_i]; + switch (section.kind) { + case "internal": + case "text": + (texts || (texts = [])).push(createUnparsedNode(section, node)); + break; + case "no-default-lib": + case "reference": + case "type": + case "lib": + (syntheticReferences || (syntheticReferences = [])).push(createUnparsedSyntheticReference(section, node)); + break; + case "prologue": + case "emitHelpers": + case "prepend": + break; + default: + ts.Debug.assertNever(section); + } + } + node.texts = texts || ts.emptyArray; + node.helpers = ts.map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, function (name) { return getAllUnscopedEmitHelpers().get(name); }); + node.syntheticReferences = syntheticReferences; + return node; + } + function mapBundleFileSectionKindToSyntaxKind(kind) { + switch (kind) { + case "prologue": return 285; + case "prepend": return 286; + case "internal": return 288; + case "text": return 287; + case "emitHelpers": + case "no-default-lib": + case "reference": + case "type": + case "lib": + return ts.Debug.fail("BundleFileSectionKind: " + kind + " not yet mapped to SyntaxKind"); + default: + return ts.Debug.assertNever(kind); + } + } + function createUnparsedNode(section, parent) { + var node = ts.createNode(mapBundleFileSectionKindToSyntaxKind(section.kind), section.pos, section.end); + node.parent = parent; + node.data = section.data; + return node; + } + function createUnparsedSyntheticReference(section, parent) { + var node = ts.createNode(289, section.pos, section.end); + node.parent = parent; + node.data = section.data; + node.section = section; + return node; + } + function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) { + var node = ts.createNode(293); + if (!ts.isString(javascriptTextOrReadFileText)) { + var cache_1 = ts.createMap(); + var textGetter_1 = function (path) { + if (path === undefined) + return undefined; + var value = cache_1.get(path); + if (value === undefined) { + value = javascriptTextOrReadFileText(path); + cache_1.set(path, value !== undefined ? value : false); + } + return value !== false ? value : undefined; + }; + var definedTextGetter_1 = function (path) { + var result = textGetter_1(path); + return result !== undefined ? result : "/* Input file " + path + " was missing */\r\n"; + }; + var buildInfo_1; + var getAndCacheBuildInfo_1 = function (getText) { + if (buildInfo_1 === undefined) { + var result = getText(); + buildInfo_1 = result !== undefined ? ts.getBuildInfo(result) : false; + } + return buildInfo_1 || undefined; + }; + node.javascriptPath = declarationTextOrJavascriptPath; + node.javascriptMapPath = javascriptMapPath; + node.declarationPath = ts.Debug.assertDefined(javascriptMapTextOrDeclarationPath); + node.declarationMapPath = declarationMapPath; + node.buildInfoPath = declarationMapTextOrBuildInfoPath; + Object.defineProperties(node, { + javascriptText: { get: function () { return definedTextGetter_1(declarationTextOrJavascriptPath); } }, + javascriptMapText: { get: function () { return textGetter_1(javascriptMapPath); } }, + declarationText: { get: function () { return definedTextGetter_1(ts.Debug.assertDefined(javascriptMapTextOrDeclarationPath)); } }, + declarationMapText: { get: function () { return textGetter_1(declarationMapPath); } }, + buildInfo: { get: function () { return getAndCacheBuildInfo_1(function () { return textGetter_1(declarationMapTextOrBuildInfoPath); }); } } + }); + } + else { + node.javascriptText = javascriptTextOrReadFileText; + node.javascriptMapPath = javascriptMapPath; + node.javascriptMapText = javascriptMapTextOrDeclarationPath; + node.declarationText = declarationTextOrJavascriptPath; + node.declarationMapPath = declarationMapPath; + node.declarationMapText = declarationMapTextOrBuildInfoPath; + node.javascriptPath = javascriptPath; + node.declarationPath = declarationPath; + node.buildInfoPath = buildInfoPath; + node.buildInfo = buildInfo; + node.oldFileOfCurrentEmit = oldFileOfCurrentEmit; + } + return node; + } + ts.createInputFiles = createInputFiles; + function updateBundle(node, sourceFiles, prepends) { + if (prepends === void 0) { prepends = ts.emptyArray; } + if (node.sourceFiles !== sourceFiles || node.prepends !== prepends) { + return createBundle(sourceFiles, prepends); + } + return node; + } + ts.updateBundle = updateBundle; + function createImmediatelyInvokedFunctionExpression(statements, param, paramValue) { + return createCall(createFunctionExpression(undefined, undefined, undefined, undefined, param ? [param] : [], undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []); + } + ts.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression; + function createImmediatelyInvokedArrowFunction(statements, param, paramValue) { + return createCall(createArrowFunction(undefined, undefined, param ? [param] : [], undefined, undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []); + } + ts.createImmediatelyInvokedArrowFunction = createImmediatelyInvokedArrowFunction; + function createComma(left, right) { + return createBinary(left, 27, right); + } + ts.createComma = createComma; + function createLessThan(left, right) { + return createBinary(left, 29, right); + } + ts.createLessThan = createLessThan; + function createAssignment(left, right) { + return createBinary(left, 62, right); + } + ts.createAssignment = createAssignment; + function createStrictEquality(left, right) { + return createBinary(left, 36, right); + } + ts.createStrictEquality = createStrictEquality; + function createStrictInequality(left, right) { + return createBinary(left, 37, right); + } + ts.createStrictInequality = createStrictInequality; + function createAdd(left, right) { + return createBinary(left, 39, right); + } + ts.createAdd = createAdd; + function createSubtract(left, right) { + return createBinary(left, 40, right); + } + ts.createSubtract = createSubtract; + function createPostfixIncrement(operand) { + return createPostfix(operand, 45); + } + ts.createPostfixIncrement = createPostfixIncrement; + function createLogicalAnd(left, right) { + return createBinary(left, 55, right); + } + ts.createLogicalAnd = createLogicalAnd; + function createLogicalOr(left, right) { + return createBinary(left, 56, right); + } + ts.createLogicalOr = createLogicalOr; + function createNullishCoalesce(left, right) { + return createBinary(left, 60, right); + } + ts.createNullishCoalesce = createNullishCoalesce; + function createLogicalNot(operand) { + return createPrefix(53, operand); + } + ts.createLogicalNot = createLogicalNot; + function createVoidZero() { + return createVoid(createLiteral(0)); + } + ts.createVoidZero = createVoidZero; + function createExportDefault(expression) { + return createExportAssignment(undefined, undefined, false, expression); + } + ts.createExportDefault = createExportDefault; + function createExternalModuleExport(exportName) { + return createExportDeclaration(undefined, undefined, createNamedExports([createExportSpecifier(undefined, exportName)])); + } + ts.createExternalModuleExport = createExternalModuleExport; + function asName(name) { + return ts.isString(name) ? createIdentifier(name) : name; + } + function asExpression(value) { + return typeof value === "string" ? createStringLiteral(value) : + typeof value === "number" ? createNumericLiteral("" + value) : + typeof value === "boolean" ? value ? createTrue() : createFalse() : + value; + } + function asNodeArray(array) { + return array ? createNodeArray(array) : undefined; + } + function asToken(value) { + return typeof value === "number" ? createToken(value) : value; + } + function asEmbeddedStatement(statement) { + return statement && ts.isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement; + } + function disposeEmitNodes(sourceFile) { + sourceFile = ts.getSourceFileOfNode(ts.getParseTreeNode(sourceFile)); + var emitNode = sourceFile && sourceFile.emitNode; + var annotatedNodes = emitNode && emitNode.annotatedNodes; + if (annotatedNodes) { + for (var _i = 0, annotatedNodes_1 = annotatedNodes; _i < annotatedNodes_1.length; _i++) { + var node = annotatedNodes_1[_i]; + node.emitNode = undefined; + } + } + } + ts.disposeEmitNodes = disposeEmitNodes; + function getOrCreateEmitNode(node) { + if (!node.emitNode) { + if (ts.isParseTreeNode(node)) { + if (node.kind === 290) { + return node.emitNode = { annotatedNodes: [node] }; + } + var sourceFile = ts.getSourceFileOfNode(ts.getParseTreeNode(ts.getSourceFileOfNode(node))); + getOrCreateEmitNode(sourceFile).annotatedNodes.push(node); + } + node.emitNode = {}; + } + return node.emitNode; + } + ts.getOrCreateEmitNode = getOrCreateEmitNode; + function removeAllComments(node) { + var emitNode = getOrCreateEmitNode(node); + emitNode.flags |= 1536; + emitNode.leadingComments = undefined; + emitNode.trailingComments = undefined; + return node; + } + ts.removeAllComments = removeAllComments; + function setTextRange(range, location) { + if (location) { + range.pos = location.pos; + range.end = location.end; + } + return range; + } + ts.setTextRange = setTextRange; + function setEmitFlags(node, emitFlags) { + getOrCreateEmitNode(node).flags = emitFlags; + return node; + } + ts.setEmitFlags = setEmitFlags; + function addEmitFlags(node, emitFlags) { + var emitNode = getOrCreateEmitNode(node); + emitNode.flags = emitNode.flags | emitFlags; + return node; + } + ts.addEmitFlags = addEmitFlags; + function getSourceMapRange(node) { + var emitNode = node.emitNode; + return (emitNode && emitNode.sourceMapRange) || node; + } + ts.getSourceMapRange = getSourceMapRange; + function setSourceMapRange(node, range) { + getOrCreateEmitNode(node).sourceMapRange = range; + return node; + } + ts.setSourceMapRange = setSourceMapRange; + var SourceMapSource; + function createSourceMapSource(fileName, text, skipTrivia) { + return new (SourceMapSource || (SourceMapSource = ts.objectAllocator.getSourceMapSourceConstructor()))(fileName, text, skipTrivia); + } + ts.createSourceMapSource = createSourceMapSource; + function getTokenSourceMapRange(node, token) { + var emitNode = node.emitNode; + var tokenSourceMapRanges = emitNode && emitNode.tokenSourceMapRanges; + return tokenSourceMapRanges && tokenSourceMapRanges[token]; + } + ts.getTokenSourceMapRange = getTokenSourceMapRange; + function setTokenSourceMapRange(node, token, range) { + var emitNode = getOrCreateEmitNode(node); + var tokenSourceMapRanges = emitNode.tokenSourceMapRanges || (emitNode.tokenSourceMapRanges = []); + tokenSourceMapRanges[token] = range; + return node; + } + ts.setTokenSourceMapRange = setTokenSourceMapRange; + function getStartsOnNewLine(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.startsOnNewLine; + } + ts.getStartsOnNewLine = getStartsOnNewLine; + function setStartsOnNewLine(node, newLine) { + getOrCreateEmitNode(node).startsOnNewLine = newLine; + return node; + } + ts.setStartsOnNewLine = setStartsOnNewLine; + function getCommentRange(node) { + var emitNode = node.emitNode; + return (emitNode && emitNode.commentRange) || node; + } + ts.getCommentRange = getCommentRange; + function setCommentRange(node, range) { + getOrCreateEmitNode(node).commentRange = range; + return node; + } + ts.setCommentRange = setCommentRange; + function getSyntheticLeadingComments(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.leadingComments; + } + ts.getSyntheticLeadingComments = getSyntheticLeadingComments; + function setSyntheticLeadingComments(node, comments) { + getOrCreateEmitNode(node).leadingComments = comments; + return node; + } + ts.setSyntheticLeadingComments = setSyntheticLeadingComments; + function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) { + return setSyntheticLeadingComments(node, ts.append(getSyntheticLeadingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text })); + } + ts.addSyntheticLeadingComment = addSyntheticLeadingComment; + function getSyntheticTrailingComments(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.trailingComments; + } + ts.getSyntheticTrailingComments = getSyntheticTrailingComments; + function setSyntheticTrailingComments(node, comments) { + getOrCreateEmitNode(node).trailingComments = comments; + return node; + } + ts.setSyntheticTrailingComments = setSyntheticTrailingComments; + function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) { + return setSyntheticTrailingComments(node, ts.append(getSyntheticTrailingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text })); + } + ts.addSyntheticTrailingComment = addSyntheticTrailingComment; + function moveSyntheticComments(node, original) { + setSyntheticLeadingComments(node, getSyntheticLeadingComments(original)); + setSyntheticTrailingComments(node, getSyntheticTrailingComments(original)); + var emit = getOrCreateEmitNode(original); + emit.leadingComments = undefined; + emit.trailingComments = undefined; + return node; + } + ts.moveSyntheticComments = moveSyntheticComments; + function getConstantValue(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.constantValue; + } + ts.getConstantValue = getConstantValue; + function setConstantValue(node, value) { + var emitNode = getOrCreateEmitNode(node); + emitNode.constantValue = value; + return node; + } + ts.setConstantValue = setConstantValue; + function addEmitHelper(node, helper) { + var emitNode = getOrCreateEmitNode(node); + emitNode.helpers = ts.append(emitNode.helpers, helper); + return node; + } + ts.addEmitHelper = addEmitHelper; + function addEmitHelpers(node, helpers) { + if (ts.some(helpers)) { + var emitNode = getOrCreateEmitNode(node); + for (var _i = 0, helpers_1 = helpers; _i < helpers_1.length; _i++) { + var helper = helpers_1[_i]; + emitNode.helpers = ts.appendIfUnique(emitNode.helpers, helper); + } + } + return node; + } + ts.addEmitHelpers = addEmitHelpers; + function removeEmitHelper(node, helper) { + var emitNode = node.emitNode; + if (emitNode) { + var helpers = emitNode.helpers; + if (helpers) { + return ts.orderedRemoveItem(helpers, helper); + } + } + return false; + } + ts.removeEmitHelper = removeEmitHelper; + function getEmitHelpers(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.helpers; + } + ts.getEmitHelpers = getEmitHelpers; + function moveEmitHelpers(source, target, predicate) { + var sourceEmitNode = source.emitNode; + var sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers; + if (!ts.some(sourceEmitHelpers)) + return; + var targetEmitNode = getOrCreateEmitNode(target); + var helpersRemoved = 0; + for (var i = 0; i < sourceEmitHelpers.length; i++) { + var helper = sourceEmitHelpers[i]; + if (predicate(helper)) { + helpersRemoved++; + targetEmitNode.helpers = ts.appendIfUnique(targetEmitNode.helpers, helper); + } + else if (helpersRemoved > 0) { + sourceEmitHelpers[i - helpersRemoved] = helper; + } + } + if (helpersRemoved > 0) { + sourceEmitHelpers.length -= helpersRemoved; + } + } + ts.moveEmitHelpers = moveEmitHelpers; + function compareEmitHelpers(x, y) { + if (x === y) + return 0; + if (x.priority === y.priority) + return 0; + if (x.priority === undefined) + return 1; + if (y.priority === undefined) + return -1; + return ts.compareValues(x.priority, y.priority); + } + ts.compareEmitHelpers = compareEmitHelpers; + function setOriginalNode(node, original) { + node.original = original; + if (original) { + var emitNode = original.emitNode; + if (emitNode) + node.emitNode = mergeEmitNode(emitNode, node.emitNode); + } + return node; + } + ts.setOriginalNode = setOriginalNode; + function mergeEmitNode(sourceEmitNode, destEmitNode) { + var flags = sourceEmitNode.flags, leadingComments = sourceEmitNode.leadingComments, trailingComments = sourceEmitNode.trailingComments, commentRange = sourceEmitNode.commentRange, sourceMapRange = sourceEmitNode.sourceMapRange, tokenSourceMapRanges = sourceEmitNode.tokenSourceMapRanges, constantValue = sourceEmitNode.constantValue, helpers = sourceEmitNode.helpers, startsOnNewLine = sourceEmitNode.startsOnNewLine; + if (!destEmitNode) + destEmitNode = {}; + if (leadingComments) + destEmitNode.leadingComments = ts.addRange(leadingComments.slice(), destEmitNode.leadingComments); + if (trailingComments) + destEmitNode.trailingComments = ts.addRange(trailingComments.slice(), destEmitNode.trailingComments); + if (flags) + destEmitNode.flags = flags; + if (commentRange) + destEmitNode.commentRange = commentRange; + if (sourceMapRange) + destEmitNode.sourceMapRange = sourceMapRange; + if (tokenSourceMapRanges) + destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges); + if (constantValue !== undefined) + destEmitNode.constantValue = constantValue; + if (helpers) + destEmitNode.helpers = ts.addRange(destEmitNode.helpers, helpers); + if (startsOnNewLine !== undefined) + destEmitNode.startsOnNewLine = startsOnNewLine; + return destEmitNode; + } + function mergeTokenSourceMapRanges(sourceRanges, destRanges) { + if (!destRanges) + destRanges = []; + for (var key in sourceRanges) { + destRanges[key] = sourceRanges[key]; + } + return destRanges; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.nullTransformationContext = { + enableEmitNotification: ts.noop, + enableSubstitution: ts.noop, + endLexicalEnvironment: ts.returnUndefined, + getCompilerOptions: ts.notImplemented, + getEmitHost: ts.notImplemented, + getEmitResolver: ts.notImplemented, + hoistFunctionDeclaration: ts.noop, + hoistVariableDeclaration: ts.noop, + isEmitNotificationEnabled: ts.notImplemented, + isSubstitutionEnabled: ts.notImplemented, + onEmitNode: ts.noop, + onSubstituteNode: ts.notImplemented, + readEmitHelpers: ts.notImplemented, + requestEmitHelper: ts.noop, + resumeLexicalEnvironment: ts.noop, + startLexicalEnvironment: ts.noop, + suspendLexicalEnvironment: ts.noop, + addDiagnostic: ts.noop, + }; + function createTypeCheck(value, tag) { + return tag === "undefined" + ? ts.createStrictEquality(value, ts.createVoidZero()) + : ts.createStrictEquality(ts.createTypeOf(value), ts.createLiteral(tag)); + } + ts.createTypeCheck = createTypeCheck; + function createMemberAccessForPropertyName(target, memberName, location) { + if (ts.isComputedPropertyName(memberName)) { + return ts.setTextRange(ts.createElementAccess(target, memberName.expression), location); + } + else { + var expression = ts.setTextRange((ts.isIdentifier(memberName) || ts.isPrivateIdentifier(memberName)) + ? ts.createPropertyAccess(target, memberName) + : ts.createElementAccess(target, memberName), memberName); + ts.getOrCreateEmitNode(expression).flags |= 64; + return expression; + } + } + ts.createMemberAccessForPropertyName = createMemberAccessForPropertyName; + function createFunctionCall(func, thisArg, argumentsList, location) { + return ts.setTextRange(ts.createCall(ts.createPropertyAccess(func, "call"), undefined, __spreadArrays([ + thisArg + ], argumentsList)), location); + } + ts.createFunctionCall = createFunctionCall; + function createFunctionApply(func, thisArg, argumentsExpression, location) { + return ts.setTextRange(ts.createCall(ts.createPropertyAccess(func, "apply"), undefined, [ + thisArg, + argumentsExpression + ]), location); + } + ts.createFunctionApply = createFunctionApply; + function createArraySlice(array, start) { + var argumentsList = []; + if (start !== undefined) { + argumentsList.push(typeof start === "number" ? ts.createLiteral(start) : start); + } + return ts.createCall(ts.createPropertyAccess(array, "slice"), undefined, argumentsList); + } + ts.createArraySlice = createArraySlice; + function createArrayConcat(array, values) { + return ts.createCall(ts.createPropertyAccess(array, "concat"), undefined, values); + } + ts.createArrayConcat = createArrayConcat; + function createMathPow(left, right, location) { + return ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Math"), "pow"), undefined, [left, right]), location); + } + ts.createMathPow = createMathPow; + function createReactNamespace(reactNamespace, parent) { + var react = ts.createIdentifier(reactNamespace || "React"); + react.flags &= ~8; + react.parent = ts.getParseTreeNode(parent); + return react; + } + function createJsxFactoryExpressionFromEntityName(jsxFactory, parent) { + if (ts.isQualifiedName(jsxFactory)) { + var left = createJsxFactoryExpressionFromEntityName(jsxFactory.left, parent); + var right = ts.createIdentifier(ts.idText(jsxFactory.right)); + right.escapedText = jsxFactory.right.escapedText; + return ts.createPropertyAccess(left, right); + } + else { + return createReactNamespace(ts.idText(jsxFactory), parent); + } + } + function createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parent) { + return jsxFactoryEntity ? + createJsxFactoryExpressionFromEntityName(jsxFactoryEntity, parent) : + ts.createPropertyAccess(createReactNamespace(reactNamespace, parent), "createElement"); + } + function createExpressionForJsxElement(jsxFactoryEntity, reactNamespace, tagName, props, children, parentElement, location) { + var argumentsList = [tagName]; + if (props) { + argumentsList.push(props); + } + if (children && children.length > 0) { + if (!props) { + argumentsList.push(ts.createNull()); + } + if (children.length > 1) { + for (var _i = 0, children_2 = children; _i < children_2.length; _i++) { + var child = children_2[_i]; + startOnNewLine(child); + argumentsList.push(child); + } + } + else { + argumentsList.push(children[0]); + } + } + return ts.setTextRange(ts.createCall(createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location); + } + ts.createExpressionForJsxElement = createExpressionForJsxElement; + function createExpressionForJsxFragment(jsxFactoryEntity, reactNamespace, children, parentElement, location) { + var tagName = ts.createPropertyAccess(createReactNamespace(reactNamespace, parentElement), "Fragment"); + var argumentsList = [tagName]; + argumentsList.push(ts.createNull()); + if (children && children.length > 0) { + if (children.length > 1) { + for (var _i = 0, children_3 = children; _i < children_3.length; _i++) { + var child = children_3[_i]; + startOnNewLine(child); + argumentsList.push(child); + } + } + else { + argumentsList.push(children[0]); + } + } + return ts.setTextRange(ts.createCall(createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location); + } + ts.createExpressionForJsxFragment = createExpressionForJsxFragment; + function getUnscopedHelperName(name) { + return ts.setEmitFlags(ts.createIdentifier(name), 4096 | 2); + } + ts.getUnscopedHelperName = getUnscopedHelperName; + ts.valuesHelper = { + name: "typescript:values", + importName: "__values", + scoped: false, + text: "\n var __values = (this && this.__values) || function(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m) return m.call(o);\n if (o && typeof o.length === \"number\") return {\n next: function () {\n if (o && i >= o.length) o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n };" + }; + function createValuesHelper(context, expression, location) { + context.requestEmitHelper(ts.valuesHelper); + return ts.setTextRange(ts.createCall(getUnscopedHelperName("__values"), undefined, [expression]), location); + } + ts.createValuesHelper = createValuesHelper; + ts.readHelper = { + name: "typescript:read", + importName: "__read", + scoped: false, + text: "\n var __read = (this && this.__read) || function (o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n };" + }; + function createReadHelper(context, iteratorRecord, count, location) { + context.requestEmitHelper(ts.readHelper); + return ts.setTextRange(ts.createCall(getUnscopedHelperName("__read"), undefined, count !== undefined + ? [iteratorRecord, ts.createLiteral(count)] + : [iteratorRecord]), location); + } + ts.createReadHelper = createReadHelper; + ts.spreadHelper = { + name: "typescript:spread", + importName: "__spread", + scoped: false, + text: "\n var __spread = (this && this.__spread) || function () {\n for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n return ar;\n };" + }; + function createSpreadHelper(context, argumentList, location) { + context.requestEmitHelper(ts.readHelper); + context.requestEmitHelper(ts.spreadHelper); + return ts.setTextRange(ts.createCall(getUnscopedHelperName("__spread"), undefined, argumentList), location); + } + ts.createSpreadHelper = createSpreadHelper; + ts.spreadArraysHelper = { + name: "typescript:spreadArrays", + importName: "__spreadArrays", + scoped: false, + text: "\n var __spreadArrays = (this && this.__spreadArrays) || function () {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n };" + }; + function createSpreadArraysHelper(context, argumentList, location) { + context.requestEmitHelper(ts.spreadArraysHelper); + return ts.setTextRange(ts.createCall(getUnscopedHelperName("__spreadArrays"), undefined, argumentList), location); + } + ts.createSpreadArraysHelper = createSpreadArraysHelper; + function createForOfBindingStatement(node, boundValue) { + if (ts.isVariableDeclarationList(node)) { + var firstDeclaration = ts.first(node.declarations); + var updatedDeclaration = ts.updateVariableDeclaration(firstDeclaration, firstDeclaration.name, undefined, boundValue); + return ts.setTextRange(ts.createVariableStatement(undefined, ts.updateVariableDeclarationList(node, [updatedDeclaration])), node); + } + else { + var updatedExpression = ts.setTextRange(ts.createAssignment(node, boundValue), node); + return ts.setTextRange(ts.createStatement(updatedExpression), node); + } + } + ts.createForOfBindingStatement = createForOfBindingStatement; + function insertLeadingStatement(dest, source) { + if (ts.isBlock(dest)) { + return ts.updateBlock(dest, ts.setTextRange(ts.createNodeArray(__spreadArrays([source], dest.statements)), dest.statements)); + } + else { + return ts.createBlock(ts.createNodeArray([dest, source]), true); + } + } + ts.insertLeadingStatement = insertLeadingStatement; + function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) { + if (!outermostLabeledStatement) { + return node; + } + var updated = ts.updateLabel(outermostLabeledStatement, outermostLabeledStatement.label, outermostLabeledStatement.statement.kind === 238 + ? restoreEnclosingLabel(node, outermostLabeledStatement.statement) + : node); + if (afterRestoreLabelCallback) { + afterRestoreLabelCallback(outermostLabeledStatement); + } + return updated; + } + ts.restoreEnclosingLabel = restoreEnclosingLabel; + function shouldBeCapturedInTempVariable(node, cacheIdentifiers) { + var target = ts.skipParentheses(node); + switch (target.kind) { + case 75: + return cacheIdentifiers; + case 104: + case 8: + case 9: + case 10: + return false; + case 192: + var elements = target.elements; + if (elements.length === 0) { + return false; + } + return true; + case 193: + return target.properties.length > 0; + default: + return true; + } + } + function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers) { + if (cacheIdentifiers === void 0) { cacheIdentifiers = false; } + var callee = skipOuterExpressions(expression, 7); + var thisArg; + var target; + if (ts.isSuperProperty(callee)) { + thisArg = ts.createThis(); + target = callee; + } + else if (callee.kind === 102) { + thisArg = ts.createThis(); + target = languageVersion < 2 + ? ts.setTextRange(ts.createIdentifier("_super"), callee) + : callee; + } + else if (ts.getEmitFlags(callee) & 4096) { + thisArg = ts.createVoidZero(); + target = parenthesizeForAccess(callee); + } + else { + switch (callee.kind) { + case 194: { + if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) { + thisArg = ts.createTempVariable(recordTempVariable); + target = ts.createPropertyAccess(ts.setTextRange(ts.createAssignment(thisArg, callee.expression), callee.expression), callee.name); + ts.setTextRange(target, callee); + } + else { + thisArg = callee.expression; + target = callee; + } + break; + } + case 195: { + if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) { + thisArg = ts.createTempVariable(recordTempVariable); + target = ts.createElementAccess(ts.setTextRange(ts.createAssignment(thisArg, callee.expression), callee.expression), callee.argumentExpression); + ts.setTextRange(target, callee); + } + else { + thisArg = callee.expression; + target = callee; + } + break; + } + default: { + thisArg = ts.createVoidZero(); + target = parenthesizeForAccess(expression); + break; + } + } + } + return { target: target, thisArg: thisArg }; + } + ts.createCallBinding = createCallBinding; + function inlineExpressions(expressions) { + return expressions.length > 10 + ? ts.createCommaList(expressions) + : ts.reduceLeft(expressions, ts.createComma); + } + ts.inlineExpressions = inlineExpressions; + function createExpressionFromEntityName(node) { + if (ts.isQualifiedName(node)) { + var left = createExpressionFromEntityName(node.left); + var right = ts.getMutableClone(node.right); + return ts.setTextRange(ts.createPropertyAccess(left, right), node); + } + else { + return ts.getMutableClone(node); + } + } + ts.createExpressionFromEntityName = createExpressionFromEntityName; + function createExpressionForPropertyName(memberName) { + if (ts.isIdentifier(memberName)) { + return ts.createLiteral(memberName); + } + else if (ts.isComputedPropertyName(memberName)) { + return ts.getMutableClone(memberName.expression); + } + else { + return ts.getMutableClone(memberName); + } + } + ts.createExpressionForPropertyName = createExpressionForPropertyName; + function createExpressionForObjectLiteralElementLike(node, property, receiver) { + if (property.name && ts.isPrivateIdentifier(property.name)) { + ts.Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals."); + } + switch (property.kind) { + case 163: + case 164: + return createExpressionForAccessorDeclaration(node.properties, property, receiver, !!node.multiLine); + case 281: + return createExpressionForPropertyAssignment(property, receiver); + case 282: + return createExpressionForShorthandPropertyAssignment(property, receiver); + case 161: + return createExpressionForMethodDeclaration(property, receiver); + } + } + ts.createExpressionForObjectLiteralElementLike = createExpressionForObjectLiteralElementLike; + function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) { + var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + if (property === firstAccessor) { + var properties_5 = []; + if (getAccessor) { + var getterFunction = ts.createFunctionExpression(getAccessor.modifiers, undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body); + ts.setTextRange(getterFunction, getAccessor); + ts.setOriginalNode(getterFunction, getAccessor); + var getter = ts.createPropertyAssignment("get", getterFunction); + properties_5.push(getter); + } + if (setAccessor) { + var setterFunction = ts.createFunctionExpression(setAccessor.modifiers, undefined, undefined, undefined, setAccessor.parameters, undefined, setAccessor.body); + ts.setTextRange(setterFunction, setAccessor); + ts.setOriginalNode(setterFunction, setAccessor); + var setter = ts.createPropertyAssignment("set", setterFunction); + properties_5.push(setter); + } + properties_5.push(ts.createPropertyAssignment("enumerable", ts.createTrue())); + properties_5.push(ts.createPropertyAssignment("configurable", ts.createTrue())); + var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [ + receiver, + createExpressionForPropertyName(property.name), + ts.createObjectLiteral(properties_5, multiLine) + ]), firstAccessor); + return ts.aggregateTransformFlags(expression); + } + return undefined; + } + function createExpressionForPropertyAssignment(property, receiver) { + return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, property.name, property.name), property.initializer), property), property)); + } + function createExpressionForShorthandPropertyAssignment(property, receiver) { + return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, property.name, property.name), ts.getSynthesizedClone(property.name)), property), property)); + } + function createExpressionForMethodDeclaration(method, receiver) { + return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, method.name, method.name), ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(method.modifiers, method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method)); + } + function getInternalName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 16384 | 32768); + } + ts.getInternalName = getInternalName; + function isInternalName(node) { + return (ts.getEmitFlags(node) & 32768) !== 0; + } + ts.isInternalName = isInternalName; + function getLocalName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 16384); + } + ts.getLocalName = getLocalName; + function isLocalName(node) { + return (ts.getEmitFlags(node) & 16384) !== 0; + } + ts.isLocalName = isLocalName; + function getExportName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 8192); + } + ts.getExportName = getExportName; + function isExportName(node) { + return (ts.getEmitFlags(node) & 8192) !== 0; + } + ts.isExportName = isExportName; + function getDeclarationName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps); + } + ts.getDeclarationName = getDeclarationName; + function getName(node, allowComments, allowSourceMaps, emitFlags) { + if (emitFlags === void 0) { emitFlags = 0; } + var nodeName = ts.getNameOfDeclaration(node); + if (nodeName && ts.isIdentifier(nodeName) && !ts.isGeneratedIdentifier(nodeName)) { + var name = ts.getMutableClone(nodeName); + emitFlags |= ts.getEmitFlags(nodeName); + if (!allowSourceMaps) + emitFlags |= 48; + if (!allowComments) + emitFlags |= 1536; + if (emitFlags) + ts.setEmitFlags(name, emitFlags); + return name; + } + return ts.getGeneratedNameForNode(node); + } + function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) { + if (ns && ts.hasModifier(node, 1)) { + return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps); + } + return getExportName(node, allowComments, allowSourceMaps); + } + ts.getExternalModuleOrNamespaceExportName = getExternalModuleOrNamespaceExportName; + function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) { + var qualifiedName = ts.createPropertyAccess(ns, ts.nodeIsSynthesized(name) ? name : ts.getSynthesizedClone(name)); + ts.setTextRange(qualifiedName, name); + var emitFlags = 0; + if (!allowSourceMaps) + emitFlags |= 48; + if (!allowComments) + emitFlags |= 1536; + if (emitFlags) + ts.setEmitFlags(qualifiedName, emitFlags); + return qualifiedName; + } + ts.getNamespaceMemberName = getNamespaceMemberName; + function convertToFunctionBody(node, multiLine) { + return ts.isBlock(node) ? node : ts.setTextRange(ts.createBlock([ts.setTextRange(ts.createReturn(node), node)], multiLine), node); + } + ts.convertToFunctionBody = convertToFunctionBody; + function convertFunctionDeclarationToExpression(node) { + if (!node.body) + return ts.Debug.fail(); + var updated = ts.createFunctionExpression(node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body); + ts.setOriginalNode(updated, node); + ts.setTextRange(updated, node); + if (ts.getStartsOnNewLine(node)) { + ts.setStartsOnNewLine(updated, true); + } + ts.aggregateTransformFlags(updated); + return updated; + } + ts.convertFunctionDeclarationToExpression = convertFunctionDeclarationToExpression; + function isUseStrictPrologue(node) { + return ts.isStringLiteral(node.expression) && node.expression.text === "use strict"; + } + function addPrologue(target, source, ensureUseStrict, visitor) { + var offset = addStandardPrologue(target, source, ensureUseStrict); + return addCustomPrologue(target, source, offset, visitor); + } + ts.addPrologue = addPrologue; + function addStandardPrologue(target, source, ensureUseStrict) { + ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array"); + var foundUseStrict = false; + var statementOffset = 0; + var numStatements = source.length; + while (statementOffset < numStatements) { + var statement = source[statementOffset]; + if (ts.isPrologueDirective(statement)) { + if (isUseStrictPrologue(statement)) { + foundUseStrict = true; + } + target.push(statement); + } + else { + break; + } + statementOffset++; + } + if (ensureUseStrict && !foundUseStrict) { + target.push(startOnNewLine(ts.createStatement(ts.createLiteral("use strict")))); + } + return statementOffset; + } + ts.addStandardPrologue = addStandardPrologue; + function addCustomPrologue(target, source, statementOffset, visitor) { + var numStatements = source.length; + while (statementOffset !== undefined && statementOffset < numStatements) { + var statement = source[statementOffset]; + if (ts.getEmitFlags(statement) & 1048576) { + ts.append(target, visitor ? ts.visitNode(statement, visitor, ts.isStatement) : statement); + } + else { + break; + } + statementOffset++; + } + return statementOffset; + } + ts.addCustomPrologue = addCustomPrologue; + function findUseStrictPrologue(statements) { + for (var _i = 0, statements_4 = statements; _i < statements_4.length; _i++) { + var statement = statements_4[_i]; + if (ts.isPrologueDirective(statement)) { + if (isUseStrictPrologue(statement)) { + return statement; + } + } + else { + break; + } + } + return undefined; + } + ts.findUseStrictPrologue = findUseStrictPrologue; + function startsWithUseStrict(statements) { + var firstStatement = ts.firstOrUndefined(statements); + return firstStatement !== undefined + && ts.isPrologueDirective(firstStatement) + && isUseStrictPrologue(firstStatement); + } + ts.startsWithUseStrict = startsWithUseStrict; + function ensureUseStrict(statements) { + var foundUseStrict = findUseStrictPrologue(statements); + if (!foundUseStrict) { + return ts.setTextRange(ts.createNodeArray(__spreadArrays([ + startOnNewLine(ts.createStatement(ts.createLiteral("use strict"))) + ], statements)), statements); + } + return statements; + } + ts.ensureUseStrict = ensureUseStrict; + function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) { + var skipped = ts.skipPartiallyEmittedExpressions(operand); + if (skipped.kind === 200) { + return operand; + } + return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) + ? ts.createParen(operand) + : operand; + } + ts.parenthesizeBinaryOperand = parenthesizeBinaryOperand; + function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) { + var binaryOperatorPrecedence = ts.getOperatorPrecedence(209, binaryOperator); + var binaryOperatorAssociativity = ts.getOperatorAssociativity(209, binaryOperator); + var emittedOperand = ts.skipPartiallyEmittedExpressions(operand); + if (!isLeftSideOfBinary && operand.kind === 202 && binaryOperatorPrecedence > 3) { + return true; + } + var operandPrecedence = ts.getExpressionPrecedence(emittedOperand); + switch (ts.compareValues(operandPrecedence, binaryOperatorPrecedence)) { + case -1: + if (!isLeftSideOfBinary + && binaryOperatorAssociativity === 1 + && operand.kind === 212) { + return false; + } + return true; + case 1: + return false; + case 0: + if (isLeftSideOfBinary) { + return binaryOperatorAssociativity === 1; + } + else { + if (ts.isBinaryExpression(emittedOperand) + && emittedOperand.operatorToken.kind === binaryOperator) { + if (operatorHasAssociativeProperty(binaryOperator)) { + return false; + } + if (binaryOperator === 39) { + var leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0; + if (ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) { + return false; + } + } + } + var operandAssociativity = ts.getExpressionAssociativity(emittedOperand); + return operandAssociativity === 0; + } + } + } + function operatorHasAssociativeProperty(binaryOperator) { + return binaryOperator === 41 + || binaryOperator === 51 + || binaryOperator === 50 + || binaryOperator === 52; + } + function getLiteralKindOfBinaryPlusOperand(node) { + node = ts.skipPartiallyEmittedExpressions(node); + if (ts.isLiteralKind(node.kind)) { + return node.kind; + } + if (node.kind === 209 && node.operatorToken.kind === 39) { + if (node.cachedLiteralKind !== undefined) { + return node.cachedLiteralKind; + } + var leftKind = getLiteralKindOfBinaryPlusOperand(node.left); + var literalKind = ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) ? leftKind : + 0; + node.cachedLiteralKind = literalKind; + return literalKind; + } + return 0; + } + function parenthesizeForConditionalHead(condition) { + var conditionalPrecedence = ts.getOperatorPrecedence(210, 57); + var emittedCondition = ts.skipPartiallyEmittedExpressions(condition); + var conditionPrecedence = ts.getExpressionPrecedence(emittedCondition); + if (ts.compareValues(conditionPrecedence, conditionalPrecedence) !== 1) { + return ts.createParen(condition); + } + return condition; + } + ts.parenthesizeForConditionalHead = parenthesizeForConditionalHead; + function parenthesizeSubexpressionOfConditionalExpression(e) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(e); + return isCommaSequence(emittedExpression) + ? ts.createParen(e) + : e; + } + ts.parenthesizeSubexpressionOfConditionalExpression = parenthesizeSubexpressionOfConditionalExpression; + function parenthesizeDefaultExpression(e) { + var check = ts.skipPartiallyEmittedExpressions(e); + var needsParens = isCommaSequence(check); + if (!needsParens) { + switch (getLeftmostExpression(check, false).kind) { + case 214: + case 201: + needsParens = true; + } + } + return needsParens ? ts.createParen(e) : e; + } + ts.parenthesizeDefaultExpression = parenthesizeDefaultExpression; + function parenthesizeForNew(expression) { + var leftmostExpr = getLeftmostExpression(expression, true); + switch (leftmostExpr.kind) { + case 196: + return ts.createParen(expression); + case 197: + return !leftmostExpr.arguments + ? ts.createParen(expression) + : expression; + } + return parenthesizeForAccess(expression); + } + ts.parenthesizeForNew = parenthesizeForNew; + function parenthesizeForAccess(expression) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isLeftHandSideExpression(emittedExpression) + && (emittedExpression.kind !== 197 || emittedExpression.arguments)) { + return expression; + } + return ts.setTextRange(ts.createParen(expression), expression); + } + ts.parenthesizeForAccess = parenthesizeForAccess; + function parenthesizePostfixOperand(operand) { + return ts.isLeftHandSideExpression(operand) + ? operand + : ts.setTextRange(ts.createParen(operand), operand); + } + ts.parenthesizePostfixOperand = parenthesizePostfixOperand; + function parenthesizePrefixOperand(operand) { + return ts.isUnaryExpression(operand) + ? operand + : ts.setTextRange(ts.createParen(operand), operand); + } + ts.parenthesizePrefixOperand = parenthesizePrefixOperand; + function parenthesizeListElements(elements) { + var result; + for (var i = 0; i < elements.length; i++) { + var element = parenthesizeExpressionForList(elements[i]); + if (result !== undefined || element !== elements[i]) { + if (result === undefined) { + result = elements.slice(0, i); + } + result.push(element); + } + } + if (result !== undefined) { + return ts.setTextRange(ts.createNodeArray(result, elements.hasTrailingComma), elements); + } + return elements; + } + ts.parenthesizeListElements = parenthesizeListElements; + function parenthesizeExpressionForList(expression) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + var expressionPrecedence = ts.getExpressionPrecedence(emittedExpression); + var commaPrecedence = ts.getOperatorPrecedence(209, 27); + return expressionPrecedence > commaPrecedence + ? expression + : ts.setTextRange(ts.createParen(expression), expression); + } + ts.parenthesizeExpressionForList = parenthesizeExpressionForList; + function parenthesizeExpressionForExpressionStatement(expression) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isCallExpression(emittedExpression)) { + var callee = emittedExpression.expression; + var kind = ts.skipPartiallyEmittedExpressions(callee).kind; + if (kind === 201 || kind === 202) { + var mutableCall = ts.getMutableClone(emittedExpression); + mutableCall.expression = ts.setTextRange(ts.createParen(callee), callee); + return recreateOuterExpressions(expression, mutableCall, 4); + } + } + var leftmostExpressionKind = getLeftmostExpression(emittedExpression, false).kind; + if (leftmostExpressionKind === 193 || leftmostExpressionKind === 201) { + return ts.setTextRange(ts.createParen(expression), expression); + } + return expression; + } + ts.parenthesizeExpressionForExpressionStatement = parenthesizeExpressionForExpressionStatement; + function parenthesizeConditionalTypeMember(member) { + return member.kind === 180 ? ts.createParenthesizedType(member) : member; + } + ts.parenthesizeConditionalTypeMember = parenthesizeConditionalTypeMember; + function parenthesizeElementTypeMember(member) { + switch (member.kind) { + case 178: + case 179: + case 170: + case 171: + return ts.createParenthesizedType(member); + } + return parenthesizeConditionalTypeMember(member); + } + ts.parenthesizeElementTypeMember = parenthesizeElementTypeMember; + function parenthesizeArrayTypeMember(member) { + switch (member.kind) { + case 172: + case 184: + case 181: + return ts.createParenthesizedType(member); + } + return parenthesizeElementTypeMember(member); + } + ts.parenthesizeArrayTypeMember = parenthesizeArrayTypeMember; + function parenthesizeElementTypeMembers(members) { + return ts.createNodeArray(ts.sameMap(members, parenthesizeElementTypeMember)); + } + ts.parenthesizeElementTypeMembers = parenthesizeElementTypeMembers; + function parenthesizeTypeParameters(typeParameters) { + if (ts.some(typeParameters)) { + var params = []; + for (var i = 0; i < typeParameters.length; ++i) { + var entry = typeParameters[i]; + params.push(i === 0 && ts.isFunctionOrConstructorTypeNode(entry) && entry.typeParameters ? + ts.createParenthesizedType(entry) : + entry); + } + return ts.createNodeArray(params); + } + } + ts.parenthesizeTypeParameters = parenthesizeTypeParameters; + function getLeftmostExpression(node, stopAtCallExpressions) { + while (true) { + switch (node.kind) { + case 208: + node = node.operand; + continue; + case 209: + node = node.left; + continue; + case 210: + node = node.condition; + continue; + case 198: + node = node.tag; + continue; + case 196: + if (stopAtCallExpressions) { + return node; + } + case 217: + case 195: + case 194: + case 218: + case 325: + node = node.expression; + continue; + } + return node; + } + } + ts.getLeftmostExpression = getLeftmostExpression; + function parenthesizeConciseBody(body) { + if (!ts.isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, false).kind === 193)) { + return ts.setTextRange(ts.createParen(body), body); + } + return body; + } + ts.parenthesizeConciseBody = parenthesizeConciseBody; + function isCommaSequence(node) { + return node.kind === 209 && node.operatorToken.kind === 27 || + node.kind === 326; + } + ts.isCommaSequence = isCommaSequence; + function isOuterExpression(node, kinds) { + if (kinds === void 0) { kinds = 7; } + switch (node.kind) { + case 200: + return (kinds & 1) !== 0; + case 199: + case 217: + case 218: + return (kinds & 2) !== 0; + case 325: + return (kinds & 4) !== 0; + } + return false; + } + ts.isOuterExpression = isOuterExpression; + function skipOuterExpressions(node, kinds) { + if (kinds === void 0) { kinds = 7; } + var previousNode; + do { + previousNode = node; + if (kinds & 1) { + node = ts.skipParentheses(node); + } + if (kinds & 2) { + node = skipAssertions(node); + } + if (kinds & 4) { + node = ts.skipPartiallyEmittedExpressions(node); + } + } while (previousNode !== node); + return node; + } + ts.skipOuterExpressions = skipOuterExpressions; + function skipAssertions(node) { + while (ts.isAssertionExpression(node) || node.kind === 218) { + node = node.expression; + } + return node; + } + ts.skipAssertions = skipAssertions; + function updateOuterExpression(outerExpression, expression) { + switch (outerExpression.kind) { + case 200: return ts.updateParen(outerExpression, expression); + case 199: return ts.updateTypeAssertion(outerExpression, outerExpression.type, expression); + case 217: return ts.updateAsExpression(outerExpression, expression, outerExpression.type); + case 218: return ts.updateNonNullExpression(outerExpression, expression); + case 325: return ts.updatePartiallyEmittedExpression(outerExpression, expression); + } + } + function isIgnorableParen(node) { + return node.kind === 200 + && ts.nodeIsSynthesized(node) + && ts.nodeIsSynthesized(ts.getSourceMapRange(node)) + && ts.nodeIsSynthesized(ts.getCommentRange(node)) + && !ts.some(ts.getSyntheticLeadingComments(node)) + && !ts.some(ts.getSyntheticTrailingComments(node)); + } + function recreateOuterExpressions(outerExpression, innerExpression, kinds) { + if (kinds === void 0) { kinds = 7; } + if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) { + return updateOuterExpression(outerExpression, recreateOuterExpressions(outerExpression.expression, innerExpression)); + } + return innerExpression; + } + ts.recreateOuterExpressions = recreateOuterExpressions; + function startOnNewLine(node) { + return ts.setStartsOnNewLine(node, true); + } + ts.startOnNewLine = startOnNewLine; + function getExternalHelpersModuleName(node) { + var parseNode = ts.getOriginalNode(node, ts.isSourceFile); + var emitNode = parseNode && parseNode.emitNode; + return emitNode && emitNode.externalHelpersModuleName; + } + ts.getExternalHelpersModuleName = getExternalHelpersModuleName; + function hasRecordedExternalHelpers(sourceFile) { + var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile); + var emitNode = parseNode && parseNode.emitNode; + return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers); + } + ts.hasRecordedExternalHelpers = hasRecordedExternalHelpers; + function createExternalHelpersImportDeclarationIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) { + if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + var namedBindings = void 0; + var moduleKind = ts.getEmitModuleKind(compilerOptions); + if (moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) { + var helpers = ts.getEmitHelpers(sourceFile); + if (helpers) { + var helperNames = []; + for (var _i = 0, helpers_2 = helpers; _i < helpers_2.length; _i++) { + var helper = helpers_2[_i]; + if (!helper.scoped) { + var importName = helper.importName; + if (importName) { + ts.pushIfUnique(helperNames, importName); + } + } + } + if (ts.some(helperNames)) { + helperNames.sort(ts.compareStringsCaseSensitive); + namedBindings = ts.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name) + ? ts.createImportSpecifier(undefined, ts.createIdentifier(name)) + : ts.createImportSpecifier(ts.createIdentifier(name), getUnscopedHelperName(name)); })); + var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile); + var emitNode = ts.getOrCreateEmitNode(parseNode); + emitNode.externalHelpers = true; + } + } + } + else { + var externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault); + if (externalHelpersModuleName) { + namedBindings = ts.createNamespaceImport(externalHelpersModuleName); + } + } + if (namedBindings) { + var externalHelpersImportDeclaration = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, namedBindings), ts.createLiteral(ts.externalHelpersModuleNameText)); + ts.addEmitFlags(externalHelpersImportDeclaration, 67108864); + return externalHelpersImportDeclaration; + } + } + } + ts.createExternalHelpersImportDeclarationIfNeeded = createExternalHelpersImportDeclarationIfNeeded; + function getOrCreateExternalHelpersModuleNameIfNeeded(node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) { + if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(node, compilerOptions)) { + var externalHelpersModuleName = getExternalHelpersModuleName(node); + if (externalHelpersModuleName) { + return externalHelpersModuleName; + } + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var create = (hasExportStarsToExportValues || (compilerOptions.esModuleInterop && hasImportStarOrImportDefault)) + && moduleKind !== ts.ModuleKind.System + && moduleKind < ts.ModuleKind.ES2015; + if (!create) { + var helpers = ts.getEmitHelpers(node); + if (helpers) { + for (var _i = 0, helpers_3 = helpers; _i < helpers_3.length; _i++) { + var helper = helpers_3[_i]; + if (!helper.scoped) { + create = true; + break; + } + } + } + } + if (create) { + var parseNode = ts.getOriginalNode(node, ts.isSourceFile); + var emitNode = ts.getOrCreateEmitNode(parseNode); + return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = ts.createUniqueName(ts.externalHelpersModuleNameText)); + } + } + } + ts.getOrCreateExternalHelpersModuleNameIfNeeded = getOrCreateExternalHelpersModuleNameIfNeeded; + function getLocalNameForExternalImport(node, sourceFile) { + var namespaceDeclaration = ts.getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !ts.isDefaultImport(node)) { + var name = namespaceDeclaration.name; + return ts.isGeneratedIdentifier(name) ? name : ts.createIdentifier(ts.getSourceTextOfNodeFromSourceFile(sourceFile, name) || ts.idText(name)); + } + if (node.kind === 254 && node.importClause) { + return ts.getGeneratedNameForNode(node); + } + if (node.kind === 260 && node.moduleSpecifier) { + return ts.getGeneratedNameForNode(node); + } + return undefined; + } + ts.getLocalNameForExternalImport = getLocalNameForExternalImport; + function getExternalModuleNameLiteral(importNode, sourceFile, host, resolver, compilerOptions) { + var moduleName = ts.getExternalModuleName(importNode); + if (moduleName.kind === 10) { + return tryGetModuleNameFromDeclaration(importNode, host, resolver, compilerOptions) + || tryRenameExternalModule(moduleName, sourceFile) + || ts.getSynthesizedClone(moduleName); + } + return undefined; + } + ts.getExternalModuleNameLiteral = getExternalModuleNameLiteral; + function tryRenameExternalModule(moduleName, sourceFile) { + var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text); + return rename && ts.createLiteral(rename); + } + function tryGetModuleNameFromFile(file, host, options) { + if (!file) { + return undefined; + } + if (file.moduleName) { + return ts.createLiteral(file.moduleName); + } + if (!file.isDeclarationFile && (options.out || options.outFile)) { + return ts.createLiteral(ts.getExternalModuleNameFromPath(host, file.fileName)); + } + return undefined; + } + ts.tryGetModuleNameFromFile = tryGetModuleNameFromFile; + function tryGetModuleNameFromDeclaration(declaration, host, resolver, compilerOptions) { + return tryGetModuleNameFromFile(resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions); + } + function getInitializerOfBindingOrAssignmentElement(bindingElement) { + if (ts.isDeclarationBindingElement(bindingElement)) { + return bindingElement.initializer; + } + if (ts.isPropertyAssignment(bindingElement)) { + var initializer = bindingElement.initializer; + return ts.isAssignmentExpression(initializer, true) + ? initializer.right + : undefined; + } + if (ts.isShorthandPropertyAssignment(bindingElement)) { + return bindingElement.objectAssignmentInitializer; + } + if (ts.isAssignmentExpression(bindingElement, true)) { + return bindingElement.right; + } + if (ts.isSpreadElement(bindingElement)) { + return getInitializerOfBindingOrAssignmentElement(bindingElement.expression); + } + } + ts.getInitializerOfBindingOrAssignmentElement = getInitializerOfBindingOrAssignmentElement; + function getTargetOfBindingOrAssignmentElement(bindingElement) { + if (ts.isDeclarationBindingElement(bindingElement)) { + return bindingElement.name; + } + if (ts.isObjectLiteralElementLike(bindingElement)) { + switch (bindingElement.kind) { + case 281: + return getTargetOfBindingOrAssignmentElement(bindingElement.initializer); + case 282: + return bindingElement.name; + case 283: + return getTargetOfBindingOrAssignmentElement(bindingElement.expression); + } + return undefined; + } + if (ts.isAssignmentExpression(bindingElement, true)) { + return getTargetOfBindingOrAssignmentElement(bindingElement.left); + } + if (ts.isSpreadElement(bindingElement)) { + return getTargetOfBindingOrAssignmentElement(bindingElement.expression); + } + return bindingElement; + } + ts.getTargetOfBindingOrAssignmentElement = getTargetOfBindingOrAssignmentElement; + function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) { + switch (bindingElement.kind) { + case 156: + case 191: + return bindingElement.dotDotDotToken; + case 213: + case 283: + return bindingElement; + } + return undefined; + } + ts.getRestIndicatorOfBindingOrAssignmentElement = getRestIndicatorOfBindingOrAssignmentElement; + function getPropertyNameOfBindingOrAssignmentElement(bindingElement) { + var propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement); + ts.Debug.assert(!!propertyName || ts.isSpreadAssignment(bindingElement), "Invalid property name for binding element."); + return propertyName; + } + ts.getPropertyNameOfBindingOrAssignmentElement = getPropertyNameOfBindingOrAssignmentElement; + function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) { + switch (bindingElement.kind) { + case 191: + if (bindingElement.propertyName) { + var propertyName = bindingElement.propertyName; + if (ts.isPrivateIdentifier(propertyName)) { + return ts.Debug.failBadSyntaxKind(propertyName); + } + return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) + ? propertyName.expression + : propertyName; + } + break; + case 281: + if (bindingElement.name) { + var propertyName = bindingElement.name; + if (ts.isPrivateIdentifier(propertyName)) { + return ts.Debug.failBadSyntaxKind(propertyName); + } + return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) + ? propertyName.expression + : propertyName; + } + break; + case 283: + if (bindingElement.name && ts.isPrivateIdentifier(bindingElement.name)) { + return ts.Debug.failBadSyntaxKind(bindingElement.name); + } + return bindingElement.name; + } + var target = getTargetOfBindingOrAssignmentElement(bindingElement); + if (target && ts.isPropertyName(target)) { + return ts.isComputedPropertyName(target) && isStringOrNumericLiteral(target.expression) + ? target.expression + : target; + } + } + ts.tryGetPropertyNameOfBindingOrAssignmentElement = tryGetPropertyNameOfBindingOrAssignmentElement; + function isStringOrNumericLiteral(node) { + var kind = node.kind; + return kind === 10 + || kind === 8; + } + function getElementsOfBindingOrAssignmentPattern(name) { + switch (name.kind) { + case 189: + case 190: + case 192: + return name.elements; + case 193: + return name.properties; + } + } + ts.getElementsOfBindingOrAssignmentPattern = getElementsOfBindingOrAssignmentPattern; + function convertToArrayAssignmentElement(element) { + if (ts.isBindingElement(element)) { + if (element.dotDotDotToken) { + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(ts.createSpread(element.name), element), element); + } + var expression = convertToAssignmentElementTarget(element.name); + return element.initializer + ? ts.setOriginalNode(ts.setTextRange(ts.createAssignment(expression, element.initializer), element), element) + : expression; + } + ts.Debug.assertNode(element, ts.isExpression); + return element; + } + ts.convertToArrayAssignmentElement = convertToArrayAssignmentElement; + function convertToObjectAssignmentElement(element) { + if (ts.isBindingElement(element)) { + if (element.dotDotDotToken) { + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(ts.createSpreadAssignment(element.name), element), element); + } + if (element.propertyName) { + var expression = convertToAssignmentElementTarget(element.name); + return ts.setOriginalNode(ts.setTextRange(ts.createPropertyAssignment(element.propertyName, element.initializer ? ts.createAssignment(expression, element.initializer) : expression), element), element); + } + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(ts.createShorthandPropertyAssignment(element.name, element.initializer), element), element); + } + ts.Debug.assertNode(element, ts.isObjectLiteralElementLike); + return element; + } + ts.convertToObjectAssignmentElement = convertToObjectAssignmentElement; + function convertToAssignmentPattern(node) { + switch (node.kind) { + case 190: + case 192: + return convertToArrayAssignmentPattern(node); + case 189: + case 193: + return convertToObjectAssignmentPattern(node); + } + } + ts.convertToAssignmentPattern = convertToAssignmentPattern; + function convertToObjectAssignmentPattern(node) { + if (ts.isObjectBindingPattern(node)) { + return ts.setOriginalNode(ts.setTextRange(ts.createObjectLiteral(ts.map(node.elements, convertToObjectAssignmentElement)), node), node); + } + ts.Debug.assertNode(node, ts.isObjectLiteralExpression); + return node; + } + ts.convertToObjectAssignmentPattern = convertToObjectAssignmentPattern; + function convertToArrayAssignmentPattern(node) { + if (ts.isArrayBindingPattern(node)) { + return ts.setOriginalNode(ts.setTextRange(ts.createArrayLiteral(ts.map(node.elements, convertToArrayAssignmentElement)), node), node); + } + ts.Debug.assertNode(node, ts.isArrayLiteralExpression); + return node; + } + ts.convertToArrayAssignmentPattern = convertToArrayAssignmentPattern; + function convertToAssignmentElementTarget(node) { + if (ts.isBindingPattern(node)) { + return convertToAssignmentPattern(node); + } + ts.Debug.assertNode(node, ts.isExpression); + return node; + } + ts.convertToAssignmentElementTarget = convertToAssignmentElementTarget; +})(ts || (ts = {})); +var ts; +(function (ts) { + var isTypeNodeOrTypeParameterDeclaration = ts.or(ts.isTypeNode, ts.isTypeParameterDeclaration); + function visitNode(node, visitor, test, lift) { + if (node === undefined || visitor === undefined) { + return node; + } + ts.aggregateTransformFlags(node); + var visited = visitor(node); + if (visited === node) { + return node; + } + var visitedNode; + if (visited === undefined) { + return undefined; + } + else if (ts.isArray(visited)) { + visitedNode = (lift || extractSingleNode)(visited); + } + else { + visitedNode = visited; + } + ts.Debug.assertNode(visitedNode, test); + ts.aggregateTransformFlags(visitedNode); + return visitedNode; + } + ts.visitNode = visitNode; + function visitNodes(nodes, visitor, test, start, count) { + if (nodes === undefined || visitor === undefined) { + return nodes; + } + var updated; + var length = nodes.length; + if (start === undefined || start < 0) { + start = 0; + } + if (count === undefined || count > length - start) { + count = length - start; + } + if (start > 0 || count < length) { + updated = ts.createNodeArray([], nodes.hasTrailingComma && start + count === length); + } + for (var i = 0; i < count; i++) { + var node = nodes[i + start]; + ts.aggregateTransformFlags(node); + var visited = node !== undefined ? visitor(node) : undefined; + if (updated !== undefined || visited === undefined || visited !== node) { + if (updated === undefined) { + updated = ts.createNodeArray(nodes.slice(0, i), nodes.hasTrailingComma); + ts.setTextRange(updated, nodes); + } + if (visited) { + if (ts.isArray(visited)) { + for (var _i = 0, visited_1 = visited; _i < visited_1.length; _i++) { + var visitedNode = visited_1[_i]; + ts.Debug.assertNode(visitedNode, test); + ts.aggregateTransformFlags(visitedNode); + updated.push(visitedNode); + } + } + else { + ts.Debug.assertNode(visited, test); + ts.aggregateTransformFlags(visited); + updated.push(visited); + } + } + } + } + return updated || nodes; + } + ts.visitNodes = visitNodes; + function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict) { + context.startLexicalEnvironment(); + statements = visitNodes(statements, visitor, ts.isStatement, start); + if (ensureUseStrict) + statements = ts.ensureUseStrict(statements); + return ts.mergeLexicalEnvironment(statements, context.endLexicalEnvironment()); + } + ts.visitLexicalEnvironment = visitLexicalEnvironment; + function visitParameterList(nodes, visitor, context, nodesVisitor) { + if (nodesVisitor === void 0) { nodesVisitor = visitNodes; } + context.startLexicalEnvironment(); + var updated = nodesVisitor(nodes, visitor, ts.isParameterDeclaration); + context.suspendLexicalEnvironment(); + return updated; + } + ts.visitParameterList = visitParameterList; + function visitFunctionBody(node, visitor, context) { + context.resumeLexicalEnvironment(); + var updated = visitNode(node, visitor, ts.isConciseBody); + var declarations = context.endLexicalEnvironment(); + if (ts.some(declarations)) { + var block = ts.convertToFunctionBody(updated); + var statements = ts.mergeLexicalEnvironment(block.statements, declarations); + return ts.updateBlock(block, statements); + } + return updated; + } + ts.visitFunctionBody = visitFunctionBody; + function visitEachChild(node, visitor, context, nodesVisitor, tokenVisitor) { + if (nodesVisitor === void 0) { nodesVisitor = visitNodes; } + if (node === undefined) { + return undefined; + } + var kind = node.kind; + if ((kind > 0 && kind <= 152) || kind === 183) { + return node; + } + switch (kind) { + case 75: + return ts.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration)); + case 153: + return ts.updateQualifiedName(node, visitNode(node.left, visitor, ts.isEntityName), visitNode(node.right, visitor, ts.isIdentifier)); + case 154: + return ts.updateComputedPropertyName(node, visitNode(node.expression, visitor, ts.isExpression)); + case 155: + return ts.updateTypeParameterDeclaration(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.constraint, visitor, ts.isTypeNode), visitNode(node.default, visitor, ts.isTypeNode)); + case 156: + return ts.updateParameter(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.dotDotDotToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isBindingName), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression)); + case 157: + return ts.updateDecorator(node, visitNode(node.expression, visitor, ts.isExpression)); + case 158: + return ts.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isToken), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression)); + case 159: + return ts.updateProperty(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken || node.exclamationToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression)); + case 160: + return ts.updateMethodSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken)); + case 161: + return ts.updateMethod(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context)); + case 162: + return ts.updateConstructor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context)); + case 163: + return ts.updateGetAccessor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context)); + case 164: + return ts.updateSetAccessor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context)); + case 165: + return ts.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 166: + return ts.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 167: + return ts.updateIndexSignature(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 168: + return ts.updateTypePredicateNodeWithModifier(node, visitNode(node.assertsModifier, visitor), visitNode(node.parameterName, visitor), visitNode(node.type, visitor, ts.isTypeNode)); + case 169: + return ts.updateTypeReferenceNode(node, visitNode(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode)); + case 170: + return ts.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 171: + return ts.updateConstructorTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 172: + return ts.updateTypeQueryNode(node, visitNode(node.exprName, visitor, ts.isEntityName)); + case 173: + return ts.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement)); + case 174: + return ts.updateArrayTypeNode(node, visitNode(node.elementType, visitor, ts.isTypeNode)); + case 175: + return ts.updateTupleTypeNode(node, nodesVisitor(node.elementTypes, visitor, ts.isTypeNode)); + case 176: + return ts.updateOptionalTypeNode(node, visitNode(node.type, visitor, ts.isTypeNode)); + case 177: + return ts.updateRestTypeNode(node, visitNode(node.type, visitor, ts.isTypeNode)); + case 178: + return ts.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode)); + case 179: + return ts.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode)); + case 180: + return ts.updateConditionalTypeNode(node, visitNode(node.checkType, visitor, ts.isTypeNode), visitNode(node.extendsType, visitor, ts.isTypeNode), visitNode(node.trueType, visitor, ts.isTypeNode), visitNode(node.falseType, visitor, ts.isTypeNode)); + case 181: + return ts.updateInferTypeNode(node, visitNode(node.typeParameter, visitor, ts.isTypeParameterDeclaration)); + case 188: + return ts.updateImportTypeNode(node, visitNode(node.argument, visitor, ts.isTypeNode), visitNode(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf); + case 182: + return ts.updateParenthesizedType(node, visitNode(node.type, visitor, ts.isTypeNode)); + case 184: + return ts.updateTypeOperatorNode(node, visitNode(node.type, visitor, ts.isTypeNode)); + case 185: + return ts.updateIndexedAccessTypeNode(node, visitNode(node.objectType, visitor, ts.isTypeNode), visitNode(node.indexType, visitor, ts.isTypeNode)); + case 186: + return ts.updateMappedTypeNode(node, visitNode(node.readonlyToken, tokenVisitor, ts.isToken), visitNode(node.typeParameter, visitor, ts.isTypeParameterDeclaration), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode)); + case 187: + return ts.updateLiteralTypeNode(node, visitNode(node.literal, visitor, ts.isExpression)); + case 189: + return ts.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement)); + case 190: + return ts.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement)); + case 191: + return ts.updateBindingElement(node, visitNode(node.dotDotDotToken, tokenVisitor, ts.isToken), visitNode(node.propertyName, visitor, ts.isPropertyName), visitNode(node.name, visitor, ts.isBindingName), visitNode(node.initializer, visitor, ts.isExpression)); + case 192: + return ts.updateArrayLiteral(node, nodesVisitor(node.elements, visitor, ts.isExpression)); + case 193: + return ts.updateObjectLiteral(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike)); + case 194: + if (node.flags & 32) { + return ts.updatePropertyAccessChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, visitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier)); + } + return ts.updatePropertyAccess(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.name, visitor, ts.isIdentifierOrPrivateIdentifier)); + case 195: + if (node.flags & 32) { + return ts.updateElementAccessChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, visitor, ts.isToken), visitNode(node.argumentExpression, visitor, ts.isExpression)); + } + return ts.updateElementAccess(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.argumentExpression, visitor, ts.isExpression)); + case 196: + if (node.flags & 32) { + return ts.updateCallChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, visitor, ts.isToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)); + } + return ts.updateCall(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)); + case 197: + return ts.updateNew(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)); + case 198: + return ts.updateTaggedTemplate(node, visitNode(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isExpression), visitNode(node.template, visitor, ts.isTemplateLiteral)); + case 199: + return ts.updateTypeAssertion(node, visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.expression, visitor, ts.isExpression)); + case 200: + return ts.updateParen(node, visitNode(node.expression, visitor, ts.isExpression)); + case 201: + return ts.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context)); + case 202: + return ts.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.equalsGreaterThanToken, visitor, ts.isToken), visitFunctionBody(node.body, visitor, context)); + case 203: + return ts.updateDelete(node, visitNode(node.expression, visitor, ts.isExpression)); + case 204: + return ts.updateTypeOf(node, visitNode(node.expression, visitor, ts.isExpression)); + case 205: + return ts.updateVoid(node, visitNode(node.expression, visitor, ts.isExpression)); + case 206: + return ts.updateAwait(node, visitNode(node.expression, visitor, ts.isExpression)); + case 207: + return ts.updatePrefix(node, visitNode(node.operand, visitor, ts.isExpression)); + case 208: + return ts.updatePostfix(node, visitNode(node.operand, visitor, ts.isExpression)); + case 209: + return ts.updateBinary(node, visitNode(node.left, visitor, ts.isExpression), visitNode(node.right, visitor, ts.isExpression), visitNode(node.operatorToken, visitor, ts.isToken)); + case 210: + return ts.updateConditional(node, visitNode(node.condition, visitor, ts.isExpression), visitNode(node.questionToken, visitor, ts.isToken), visitNode(node.whenTrue, visitor, ts.isExpression), visitNode(node.colonToken, visitor, ts.isToken), visitNode(node.whenFalse, visitor, ts.isExpression)); + case 211: + return ts.updateTemplateExpression(node, visitNode(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan)); + case 212: + return ts.updateYield(node, visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.expression, visitor, ts.isExpression)); + case 213: + return ts.updateSpread(node, visitNode(node.expression, visitor, ts.isExpression)); + case 214: + return ts.updateClassExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement)); + case 216: + return ts.updateExpressionWithTypeArguments(node, nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.expression, visitor, ts.isExpression)); + case 217: + return ts.updateAsExpression(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.type, visitor, ts.isTypeNode)); + case 218: + return ts.updateNonNullExpression(node, visitNode(node.expression, visitor, ts.isExpression)); + case 219: + return ts.updateMetaProperty(node, visitNode(node.name, visitor, ts.isIdentifier)); + case 221: + return ts.updateTemplateSpan(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail)); + case 223: + return ts.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + case 225: + return ts.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.declarationList, visitor, ts.isVariableDeclarationList)); + case 226: + return ts.updateExpressionStatement(node, visitNode(node.expression, visitor, ts.isExpression)); + case 227: + return ts.updateIf(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.thenStatement, visitor, ts.isStatement, ts.liftToBlock), visitNode(node.elseStatement, visitor, ts.isStatement, ts.liftToBlock)); + case 228: + return ts.updateDo(node, visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock), visitNode(node.expression, visitor, ts.isExpression)); + case 229: + return ts.updateWhile(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 230: + return ts.updateFor(node, visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.condition, visitor, ts.isExpression), visitNode(node.incrementor, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 231: + return ts.updateForIn(node, visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 232: + return ts.updateForOf(node, visitNode(node.awaitModifier, visitor, ts.isToken), visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 233: + return ts.updateContinue(node, visitNode(node.label, visitor, ts.isIdentifier)); + case 234: + return ts.updateBreak(node, visitNode(node.label, visitor, ts.isIdentifier)); + case 235: + return ts.updateReturn(node, visitNode(node.expression, visitor, ts.isExpression)); + case 236: + return ts.updateWith(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 237: + return ts.updateSwitch(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.caseBlock, visitor, ts.isCaseBlock)); + case 238: + return ts.updateLabel(node, visitNode(node.label, visitor, ts.isIdentifier), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + case 239: + return ts.updateThrow(node, visitNode(node.expression, visitor, ts.isExpression)); + case 240: + return ts.updateTry(node, visitNode(node.tryBlock, visitor, ts.isBlock), visitNode(node.catchClause, visitor, ts.isCatchClause), visitNode(node.finallyBlock, visitor, ts.isBlock)); + case 242: + return ts.updateTypeScriptVariableDeclaration(node, visitNode(node.name, visitor, ts.isBindingName), visitNode(node.exclamationToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression)); + case 243: + return ts.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration)); + case 244: + return ts.updateFunctionDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context)); + case 245: + return ts.updateClassDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement)); + case 246: + return ts.updateInterfaceDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement)); + case 247: + return ts.updateTypeAliasDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode)); + case 248: + return ts.updateEnumDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember)); + case 249: + return ts.updateModuleDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.body, visitor, ts.isModuleBody)); + case 250: + return ts.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + case 251: + return ts.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause)); + case 252: + return ts.updateNamespaceExportDeclaration(node, visitNode(node.name, visitor, ts.isIdentifier)); + case 253: + return ts.updateImportEqualsDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.moduleReference, visitor, ts.isModuleReference)); + case 254: + return ts.updateImportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.importClause, visitor, ts.isImportClause), visitNode(node.moduleSpecifier, visitor, ts.isExpression)); + case 255: + return ts.updateImportClause(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.namedBindings, visitor, ts.isNamedImportBindings), node.isTypeOnly); + case 256: + return ts.updateNamespaceImport(node, visitNode(node.name, visitor, ts.isIdentifier)); + case 262: + return ts.updateNamespaceExport(node, visitNode(node.name, visitor, ts.isIdentifier)); + case 257: + return ts.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier)); + case 258: + return ts.updateImportSpecifier(node, visitNode(node.propertyName, visitor, ts.isIdentifier), visitNode(node.name, visitor, ts.isIdentifier)); + case 259: + return ts.updateExportAssignment(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.expression, visitor, ts.isExpression)); + case 260: + return ts.updateExportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.exportClause, visitor, ts.isNamedExportBindings), visitNode(node.moduleSpecifier, visitor, ts.isExpression), node.isTypeOnly); + case 261: + return ts.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier)); + case 263: + return ts.updateExportSpecifier(node, visitNode(node.propertyName, visitor, ts.isIdentifier), visitNode(node.name, visitor, ts.isIdentifier)); + case 265: + return ts.updateExternalModuleReference(node, visitNode(node.expression, visitor, ts.isExpression)); + case 266: + return ts.updateJsxElement(node, visitNode(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), visitNode(node.closingElement, visitor, ts.isJsxClosingElement)); + case 267: + return ts.updateJsxSelfClosingElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.attributes, visitor, ts.isJsxAttributes)); + case 268: + return ts.updateJsxOpeningElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.attributes, visitor, ts.isJsxAttributes)); + case 269: + return ts.updateJsxClosingElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression)); + case 270: + return ts.updateJsxFragment(node, visitNode(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), visitNode(node.closingFragment, visitor, ts.isJsxClosingFragment)); + case 273: + return ts.updateJsxAttribute(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.initializer, visitor, ts.isStringLiteralOrJsxExpression)); + case 274: + return ts.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike)); + case 275: + return ts.updateJsxSpreadAttribute(node, visitNode(node.expression, visitor, ts.isExpression)); + case 276: + return ts.updateJsxExpression(node, visitNode(node.expression, visitor, ts.isExpression)); + case 277: + return ts.updateCaseClause(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement)); + case 278: + return ts.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + case 279: + return ts.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments)); + case 280: + return ts.updateCatchClause(node, visitNode(node.variableDeclaration, visitor, ts.isVariableDeclaration), visitNode(node.block, visitor, ts.isBlock)); + case 281: + return ts.updatePropertyAssignment(node, visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.initializer, visitor, ts.isExpression)); + case 282: + return ts.updateShorthandPropertyAssignment(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.objectAssignmentInitializer, visitor, ts.isExpression)); + case 283: + return ts.updateSpreadAssignment(node, visitNode(node.expression, visitor, ts.isExpression)); + case 284: + return ts.updateEnumMember(node, visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.initializer, visitor, ts.isExpression)); + case 290: + return ts.updateSourceFileNode(node, visitLexicalEnvironment(node.statements, visitor, context)); + case 325: + return ts.updatePartiallyEmittedExpression(node, visitNode(node.expression, visitor, ts.isExpression)); + case 326: + return ts.updateCommaList(node, nodesVisitor(node.elements, visitor, ts.isExpression)); + default: + return node; + } + } + ts.visitEachChild = visitEachChild; + function extractSingleNode(nodes) { + ts.Debug.assert(nodes.length <= 1, "Too many nodes written to output."); + return ts.singleOrUndefined(nodes); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function reduceNode(node, f, initial) { + return node ? f(initial, node) : initial; + } + function reduceNodeArray(nodes, f, initial) { + return nodes ? f(initial, nodes) : initial; + } + function reduceEachChild(node, initial, cbNode, cbNodeArray) { + if (node === undefined) { + return initial; + } + var reduceNodes = cbNodeArray ? reduceNodeArray : ts.reduceLeft; + var cbNodes = cbNodeArray || cbNode; + var kind = node.kind; + if ((kind > 0 && kind <= 152)) { + return initial; + } + if ((kind >= 168 && kind <= 187)) { + return initial; + } + var result = initial; + switch (node.kind) { + case 222: + case 224: + case 215: + case 241: + case 324: + break; + case 153: + result = reduceNode(node.left, cbNode, result); + result = reduceNode(node.right, cbNode, result); + break; + case 154: + result = reduceNode(node.expression, cbNode, result); + break; + case 156: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 157: + result = reduceNode(node.expression, cbNode, result); + break; + case 158: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.questionToken, cbNode, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 159: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 161: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 162: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.body, cbNode, result); + break; + case 163: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 164: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.body, cbNode, result); + break; + case 189: + case 190: + result = reduceNodes(node.elements, cbNodes, result); + break; + case 191: + result = reduceNode(node.propertyName, cbNode, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 192: + result = reduceNodes(node.elements, cbNodes, result); + break; + case 193: + result = reduceNodes(node.properties, cbNodes, result); + break; + case 194: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.name, cbNode, result); + break; + case 195: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.argumentExpression, cbNode, result); + break; + case 196: + result = reduceNode(node.expression, cbNode, result); + result = reduceNodes(node.typeArguments, cbNodes, result); + result = reduceNodes(node.arguments, cbNodes, result); + break; + case 197: + result = reduceNode(node.expression, cbNode, result); + result = reduceNodes(node.typeArguments, cbNodes, result); + result = reduceNodes(node.arguments, cbNodes, result); + break; + case 198: + result = reduceNode(node.tag, cbNode, result); + result = reduceNodes(node.typeArguments, cbNodes, result); + result = reduceNode(node.template, cbNode, result); + break; + case 199: + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.expression, cbNode, result); + break; + case 201: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 202: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 200: + case 203: + case 204: + case 205: + case 206: + case 212: + case 213: + case 218: + result = reduceNode(node.expression, cbNode, result); + break; + case 207: + case 208: + result = reduceNode(node.operand, cbNode, result); + break; + case 209: + result = reduceNode(node.left, cbNode, result); + result = reduceNode(node.right, cbNode, result); + break; + case 210: + result = reduceNode(node.condition, cbNode, result); + result = reduceNode(node.whenTrue, cbNode, result); + result = reduceNode(node.whenFalse, cbNode, result); + break; + case 211: + result = reduceNode(node.head, cbNode, result); + result = reduceNodes(node.templateSpans, cbNodes, result); + break; + case 214: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.heritageClauses, cbNodes, result); + result = reduceNodes(node.members, cbNodes, result); + break; + case 216: + result = reduceNode(node.expression, cbNode, result); + result = reduceNodes(node.typeArguments, cbNodes, result); + break; + case 217: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.type, cbNode, result); + break; + case 221: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.literal, cbNode, result); + break; + case 223: + result = reduceNodes(node.statements, cbNodes, result); + break; + case 225: + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.declarationList, cbNode, result); + break; + case 226: + result = reduceNode(node.expression, cbNode, result); + break; + case 227: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.thenStatement, cbNode, result); + result = reduceNode(node.elseStatement, cbNode, result); + break; + case 228: + result = reduceNode(node.statement, cbNode, result); + result = reduceNode(node.expression, cbNode, result); + break; + case 229: + case 236: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.statement, cbNode, result); + break; + case 230: + result = reduceNode(node.initializer, cbNode, result); + result = reduceNode(node.condition, cbNode, result); + result = reduceNode(node.incrementor, cbNode, result); + result = reduceNode(node.statement, cbNode, result); + break; + case 231: + case 232: + result = reduceNode(node.initializer, cbNode, result); + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.statement, cbNode, result); + break; + case 235: + case 239: + result = reduceNode(node.expression, cbNode, result); + break; + case 237: + result = reduceNode(node.expression, cbNode, result); + result = reduceNode(node.caseBlock, cbNode, result); + break; + case 238: + result = reduceNode(node.label, cbNode, result); + result = reduceNode(node.statement, cbNode, result); + break; + case 240: + result = reduceNode(node.tryBlock, cbNode, result); + result = reduceNode(node.catchClause, cbNode, result); + result = reduceNode(node.finallyBlock, cbNode, result); + break; + case 242: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 243: + result = reduceNodes(node.declarations, cbNodes, result); + break; + case 244: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.parameters, cbNodes, result); + result = reduceNode(node.type, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 245: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.typeParameters, cbNodes, result); + result = reduceNodes(node.heritageClauses, cbNodes, result); + result = reduceNodes(node.members, cbNodes, result); + break; + case 248: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNodes(node.members, cbNodes, result); + break; + case 249: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.body, cbNode, result); + break; + case 250: + result = reduceNodes(node.statements, cbNodes, result); + break; + case 251: + result = reduceNodes(node.clauses, cbNodes, result); + break; + case 253: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.moduleReference, cbNode, result); + break; + case 254: + result = reduceNodes(node.decorators, cbNodes, result); + result = reduceNodes(node.modifiers, cbNodes, result); + result = reduceNode(node.importClause, cbNode, result); + result = reduceNode(node.moduleSpecifier, cbNode, result); + break; + case 255: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.namedBindings, cbNode, result); + break; + case 256: + result = reduceNode(node.name, cbNode, result); + break; + case 262: + result = reduceNode(node.name, cbNode, result); + break; + case 257: + case 261: + result = reduceNodes(node.elements, cbNodes, result); + break; + case 258: + case 263: + result = reduceNode(node.propertyName, cbNode, result); + result = reduceNode(node.name, cbNode, result); + break; + case 259: + result = ts.reduceLeft(node.decorators, cbNode, result); + result = ts.reduceLeft(node.modifiers, cbNode, result); + result = reduceNode(node.expression, cbNode, result); + break; + case 260: + result = ts.reduceLeft(node.decorators, cbNode, result); + result = ts.reduceLeft(node.modifiers, cbNode, result); + result = reduceNode(node.exportClause, cbNode, result); + result = reduceNode(node.moduleSpecifier, cbNode, result); + break; + case 265: + result = reduceNode(node.expression, cbNode, result); + break; + case 266: + result = reduceNode(node.openingElement, cbNode, result); + result = ts.reduceLeft(node.children, cbNode, result); + result = reduceNode(node.closingElement, cbNode, result); + break; + case 270: + result = reduceNode(node.openingFragment, cbNode, result); + result = ts.reduceLeft(node.children, cbNode, result); + result = reduceNode(node.closingFragment, cbNode, result); + break; + case 267: + case 268: + result = reduceNode(node.tagName, cbNode, result); + result = reduceNodes(node.typeArguments, cbNode, result); + result = reduceNode(node.attributes, cbNode, result); + break; + case 274: + result = reduceNodes(node.properties, cbNodes, result); + break; + case 269: + result = reduceNode(node.tagName, cbNode, result); + break; + case 273: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 275: + result = reduceNode(node.expression, cbNode, result); + break; + case 276: + result = reduceNode(node.expression, cbNode, result); + break; + case 277: + result = reduceNode(node.expression, cbNode, result); + case 278: + result = reduceNodes(node.statements, cbNodes, result); + break; + case 279: + result = reduceNodes(node.types, cbNodes, result); + break; + case 280: + result = reduceNode(node.variableDeclaration, cbNode, result); + result = reduceNode(node.block, cbNode, result); + break; + case 281: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 282: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.objectAssignmentInitializer, cbNode, result); + break; + case 283: + result = reduceNode(node.expression, cbNode, result); + break; + case 284: + result = reduceNode(node.name, cbNode, result); + result = reduceNode(node.initializer, cbNode, result); + break; + case 290: + result = reduceNodes(node.statements, cbNodes, result); + break; + case 325: + result = reduceNode(node.expression, cbNode, result); + break; + case 326: + result = reduceNodes(node.elements, cbNodes, result); + break; + default: + break; + } + return result; + } + ts.reduceEachChild = reduceEachChild; + function mergeLexicalEnvironment(statements, declarations) { + if (!ts.some(declarations)) { + return statements; + } + return ts.isNodeArray(statements) + ? ts.setTextRange(ts.createNodeArray(ts.insertStatementsAfterStandardPrologue(statements.slice(), declarations)), statements) + : ts.insertStatementsAfterStandardPrologue(statements, declarations); + } + ts.mergeLexicalEnvironment = mergeLexicalEnvironment; + function liftToBlock(nodes) { + ts.Debug.assert(ts.every(nodes, ts.isStatement), "Cannot lift nodes to a Block."); + return ts.singleOrUndefined(nodes) || ts.createBlock(nodes); + } + ts.liftToBlock = liftToBlock; + function aggregateTransformFlags(node) { + aggregateTransformFlagsForNode(node); + return node; + } + ts.aggregateTransformFlags = aggregateTransformFlags; + function aggregateTransformFlagsForNode(node) { + if (node === undefined) { + return 0; + } + if (node.transformFlags & 536870912) { + return node.transformFlags & ~ts.getTransformFlagsSubtreeExclusions(node.kind); + } + var subtreeFlags = aggregateTransformFlagsForSubtree(node); + return ts.computeTransformFlagsForNode(node, subtreeFlags); + } + function aggregateTransformFlagsForNodeArray(nodes) { + if (nodes === undefined) { + return 0; + } + var subtreeFlags = 0; + var nodeArrayFlags = 0; + for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) { + var node = nodes_3[_i]; + subtreeFlags |= aggregateTransformFlagsForNode(node); + nodeArrayFlags |= node.transformFlags & ~536870912; + } + nodes.transformFlags = nodeArrayFlags | 536870912; + return subtreeFlags; + } + function aggregateTransformFlagsForSubtree(node) { + if (ts.hasModifier(node, 2) || (ts.isTypeNode(node) && node.kind !== 216)) { + return 0; + } + return reduceEachChild(node, 0, aggregateTransformFlagsForChildNode, aggregateTransformFlagsForChildNodes); + } + function aggregateTransformFlagsForChildNode(transformFlags, node) { + return transformFlags | aggregateTransformFlagsForNode(node); + } + function aggregateTransformFlagsForChildNodes(transformFlags, nodes) { + return transformFlags | aggregateTransformFlagsForNodeArray(nodes); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) { + var _a = generatorOptions.extendedDiagnostics + ? ts.performance.createTimer("Source Map", "beforeSourcemap", "afterSourcemap") + : ts.performance.nullTimer, enter = _a.enter, exit = _a.exit; + var rawSources = []; + var sources = []; + var sourceToSourceIndexMap = ts.createMap(); + var sourcesContent; + var names = []; + var nameToNameIndexMap; + var mappings = ""; + var lastGeneratedLine = 0; + var lastGeneratedCharacter = 0; + var lastSourceIndex = 0; + var lastSourceLine = 0; + var lastSourceCharacter = 0; + var lastNameIndex = 0; + var hasLast = false; + var pendingGeneratedLine = 0; + var pendingGeneratedCharacter = 0; + var pendingSourceIndex = 0; + var pendingSourceLine = 0; + var pendingSourceCharacter = 0; + var pendingNameIndex = 0; + var hasPending = false; + var hasPendingSource = false; + var hasPendingName = false; + return { + getSources: function () { return rawSources; }, + addSource: addSource, + setSourceContent: setSourceContent, + addName: addName, + addMapping: addMapping, + appendSourceMap: appendSourceMap, + toJSON: toJSON, + toString: function () { return JSON.stringify(toJSON()); } + }; + function addSource(fileName) { + enter(); + var source = ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, fileName, host.getCurrentDirectory(), host.getCanonicalFileName, true); + var sourceIndex = sourceToSourceIndexMap.get(source); + if (sourceIndex === undefined) { + sourceIndex = sources.length; + sources.push(source); + rawSources.push(fileName); + sourceToSourceIndexMap.set(source, sourceIndex); + } + exit(); + return sourceIndex; + } + function setSourceContent(sourceIndex, content) { + enter(); + if (content !== null) { + if (!sourcesContent) + sourcesContent = []; + while (sourcesContent.length < sourceIndex) { + sourcesContent.push(null); + } + sourcesContent[sourceIndex] = content; + } + exit(); + } + function addName(name) { + enter(); + if (!nameToNameIndexMap) + nameToNameIndexMap = ts.createMap(); + var nameIndex = nameToNameIndexMap.get(name); + if (nameIndex === undefined) { + nameIndex = names.length; + names.push(name); + nameToNameIndexMap.set(name, nameIndex); + } + exit(); + return nameIndex; + } + function isNewGeneratedPosition(generatedLine, generatedCharacter) { + return !hasPending + || pendingGeneratedLine !== generatedLine + || pendingGeneratedCharacter !== generatedCharacter; + } + function isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter) { + return sourceIndex !== undefined + && sourceLine !== undefined + && sourceCharacter !== undefined + && pendingSourceIndex === sourceIndex + && (pendingSourceLine > sourceLine + || pendingSourceLine === sourceLine && pendingSourceCharacter > sourceCharacter); + } + function addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, nameIndex) { + ts.Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack"); + ts.Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative"); + ts.Debug.assert(sourceIndex === undefined || sourceIndex >= 0, "sourceIndex cannot be negative"); + ts.Debug.assert(sourceLine === undefined || sourceLine >= 0, "sourceLine cannot be negative"); + ts.Debug.assert(sourceCharacter === undefined || sourceCharacter >= 0, "sourceCharacter cannot be negative"); + enter(); + if (isNewGeneratedPosition(generatedLine, generatedCharacter) || + isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter)) { + commitPendingMapping(); + pendingGeneratedLine = generatedLine; + pendingGeneratedCharacter = generatedCharacter; + hasPendingSource = false; + hasPendingName = false; + hasPending = true; + } + if (sourceIndex !== undefined && sourceLine !== undefined && sourceCharacter !== undefined) { + pendingSourceIndex = sourceIndex; + pendingSourceLine = sourceLine; + pendingSourceCharacter = sourceCharacter; + hasPendingSource = true; + if (nameIndex !== undefined) { + pendingNameIndex = nameIndex; + hasPendingName = true; + } + } + exit(); + } + function appendSourceMap(generatedLine, generatedCharacter, map, sourceMapPath, start, end) { + ts.Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack"); + ts.Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative"); + enter(); + var sourceIndexToNewSourceIndexMap = []; + var nameIndexToNewNameIndexMap; + var mappingIterator = decodeMappings(map.mappings); + for (var iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) { + var raw = iterResult.value; + if (end && (raw.generatedLine > end.line || + (raw.generatedLine === end.line && raw.generatedCharacter > end.character))) { + break; + } + if (start && (raw.generatedLine < start.line || + (start.line === raw.generatedLine && raw.generatedCharacter < start.character))) { + continue; + } + var newSourceIndex = void 0; + var newSourceLine = void 0; + var newSourceCharacter = void 0; + var newNameIndex = void 0; + if (raw.sourceIndex !== undefined) { + newSourceIndex = sourceIndexToNewSourceIndexMap[raw.sourceIndex]; + if (newSourceIndex === undefined) { + var rawPath = map.sources[raw.sourceIndex]; + var relativePath = map.sourceRoot ? ts.combinePaths(map.sourceRoot, rawPath) : rawPath; + var combinedPath = ts.combinePaths(ts.getDirectoryPath(sourceMapPath), relativePath); + sourceIndexToNewSourceIndexMap[raw.sourceIndex] = newSourceIndex = addSource(combinedPath); + if (map.sourcesContent && typeof map.sourcesContent[raw.sourceIndex] === "string") { + setSourceContent(newSourceIndex, map.sourcesContent[raw.sourceIndex]); + } + } + newSourceLine = raw.sourceLine; + newSourceCharacter = raw.sourceCharacter; + if (map.names && raw.nameIndex !== undefined) { + if (!nameIndexToNewNameIndexMap) + nameIndexToNewNameIndexMap = []; + newNameIndex = nameIndexToNewNameIndexMap[raw.nameIndex]; + if (newNameIndex === undefined) { + nameIndexToNewNameIndexMap[raw.nameIndex] = newNameIndex = addName(map.names[raw.nameIndex]); + } + } + } + var rawGeneratedLine = raw.generatedLine - (start ? start.line : 0); + var newGeneratedLine = rawGeneratedLine + generatedLine; + var rawGeneratedCharacter = start && start.line === raw.generatedLine ? raw.generatedCharacter - start.character : raw.generatedCharacter; + var newGeneratedCharacter = rawGeneratedLine === 0 ? rawGeneratedCharacter + generatedCharacter : rawGeneratedCharacter; + addMapping(newGeneratedLine, newGeneratedCharacter, newSourceIndex, newSourceLine, newSourceCharacter, newNameIndex); + } + exit(); + } + function shouldCommitMapping() { + return !hasLast + || lastGeneratedLine !== pendingGeneratedLine + || lastGeneratedCharacter !== pendingGeneratedCharacter + || lastSourceIndex !== pendingSourceIndex + || lastSourceLine !== pendingSourceLine + || lastSourceCharacter !== pendingSourceCharacter + || lastNameIndex !== pendingNameIndex; + } + function commitPendingMapping() { + if (!hasPending || !shouldCommitMapping()) { + return; + } + enter(); + if (lastGeneratedLine < pendingGeneratedLine) { + do { + mappings += ";"; + lastGeneratedLine++; + lastGeneratedCharacter = 0; + } while (lastGeneratedLine < pendingGeneratedLine); + } + else { + ts.Debug.assertEqual(lastGeneratedLine, pendingGeneratedLine, "generatedLine cannot backtrack"); + if (hasLast) { + mappings += ","; + } + } + mappings += base64VLQFormatEncode(pendingGeneratedCharacter - lastGeneratedCharacter); + lastGeneratedCharacter = pendingGeneratedCharacter; + if (hasPendingSource) { + mappings += base64VLQFormatEncode(pendingSourceIndex - lastSourceIndex); + lastSourceIndex = pendingSourceIndex; + mappings += base64VLQFormatEncode(pendingSourceLine - lastSourceLine); + lastSourceLine = pendingSourceLine; + mappings += base64VLQFormatEncode(pendingSourceCharacter - lastSourceCharacter); + lastSourceCharacter = pendingSourceCharacter; + if (hasPendingName) { + mappings += base64VLQFormatEncode(pendingNameIndex - lastNameIndex); + lastNameIndex = pendingNameIndex; + } + } + hasLast = true; + exit(); + } + function toJSON() { + commitPendingMapping(); + return { + version: 3, + file: file, + sourceRoot: sourceRoot, + sources: sources, + names: names, + mappings: mappings, + sourcesContent: sourcesContent, + }; + } + } + ts.createSourceMapGenerator = createSourceMapGenerator; + var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\s*$/; + var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/; + function getLineInfo(text, lineStarts) { + return { + getLineCount: function () { return lineStarts.length; }, + getLineText: function (line) { return text.substring(lineStarts[line], lineStarts[line + 1]); } + }; + } + ts.getLineInfo = getLineInfo; + function tryGetSourceMappingURL(lineInfo) { + for (var index = lineInfo.getLineCount() - 1; index >= 0; index--) { + var line = lineInfo.getLineText(index); + var comment = sourceMapCommentRegExp.exec(line); + if (comment) { + return comment[1]; + } + else if (!line.match(whitespaceOrMapCommentRegExp)) { + break; + } + } + } + ts.tryGetSourceMappingURL = tryGetSourceMappingURL; + function isStringOrNull(x) { + return typeof x === "string" || x === null; + } + function isRawSourceMap(x) { + return x !== null + && typeof x === "object" + && x.version === 3 + && typeof x.file === "string" + && typeof x.mappings === "string" + && ts.isArray(x.sources) && ts.every(x.sources, ts.isString) + && (x.sourceRoot === undefined || x.sourceRoot === null || typeof x.sourceRoot === "string") + && (x.sourcesContent === undefined || x.sourcesContent === null || ts.isArray(x.sourcesContent) && ts.every(x.sourcesContent, isStringOrNull)) + && (x.names === undefined || x.names === null || ts.isArray(x.names) && ts.every(x.names, ts.isString)); + } + ts.isRawSourceMap = isRawSourceMap; + function tryParseRawSourceMap(text) { + try { + var parsed = JSON.parse(text); + if (isRawSourceMap(parsed)) { + return parsed; + } + } + catch (_a) { + } + return undefined; + } + ts.tryParseRawSourceMap = tryParseRawSourceMap; + function decodeMappings(mappings) { + var done = false; + var pos = 0; + var generatedLine = 0; + var generatedCharacter = 0; + var sourceIndex = 0; + var sourceLine = 0; + var sourceCharacter = 0; + var nameIndex = 0; + var error; + return { + get pos() { return pos; }, + get error() { return error; }, + get state() { return captureMapping(true, true); }, + next: function () { + while (!done && pos < mappings.length) { + var ch = mappings.charCodeAt(pos); + if (ch === 59) { + generatedLine++; + generatedCharacter = 0; + pos++; + continue; + } + if (ch === 44) { + pos++; + continue; + } + var hasSource = false; + var hasName = false; + generatedCharacter += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (generatedCharacter < 0) + return setErrorAndStopIterating("Invalid generatedCharacter found"); + if (!isSourceMappingSegmentEnd()) { + hasSource = true; + sourceIndex += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceIndex < 0) + return setErrorAndStopIterating("Invalid sourceIndex found"); + if (isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Format: No entries after sourceIndex"); + sourceLine += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceLine < 0) + return setErrorAndStopIterating("Invalid sourceLine found"); + if (isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Format: No entries after sourceLine"); + sourceCharacter += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceCharacter < 0) + return setErrorAndStopIterating("Invalid sourceCharacter found"); + if (!isSourceMappingSegmentEnd()) { + hasName = true; + nameIndex += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (nameIndex < 0) + return setErrorAndStopIterating("Invalid nameIndex found"); + if (!isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Error Format: Entries after nameIndex"); + } + } + return { value: captureMapping(hasSource, hasName), done: done }; + } + return stopIterating(); + } + }; + function captureMapping(hasSource, hasName) { + return { + generatedLine: generatedLine, + generatedCharacter: generatedCharacter, + sourceIndex: hasSource ? sourceIndex : undefined, + sourceLine: hasSource ? sourceLine : undefined, + sourceCharacter: hasSource ? sourceCharacter : undefined, + nameIndex: hasName ? nameIndex : undefined + }; + } + function stopIterating() { + done = true; + return { value: undefined, done: true }; + } + function setError(message) { + if (error === undefined) { + error = message; + } + } + function setErrorAndStopIterating(message) { + setError(message); + return stopIterating(); + } + function hasReportedError() { + return error !== undefined; + } + function isSourceMappingSegmentEnd() { + return (pos === mappings.length || + mappings.charCodeAt(pos) === 44 || + mappings.charCodeAt(pos) === 59); + } + function base64VLQFormatDecode() { + var moreDigits = true; + var shiftCount = 0; + var value = 0; + for (; moreDigits; pos++) { + if (pos >= mappings.length) + return setError("Error in decoding base64VLQFormatDecode, past the mapping string"), -1; + var currentByte = base64FormatDecode(mappings.charCodeAt(pos)); + if (currentByte === -1) + return setError("Invalid character in VLQ"), -1; + moreDigits = (currentByte & 32) !== 0; + value = value | ((currentByte & 31) << shiftCount); + shiftCount += 5; + } + if ((value & 1) === 0) { + value = value >> 1; + } + else { + value = value >> 1; + value = -value; + } + return value; + } + } + ts.decodeMappings = decodeMappings; + function sameMapping(left, right) { + return left === right + || left.generatedLine === right.generatedLine + && left.generatedCharacter === right.generatedCharacter + && left.sourceIndex === right.sourceIndex + && left.sourceLine === right.sourceLine + && left.sourceCharacter === right.sourceCharacter + && left.nameIndex === right.nameIndex; + } + ts.sameMapping = sameMapping; + function isSourceMapping(mapping) { + return mapping.sourceIndex !== undefined + && mapping.sourceLine !== undefined + && mapping.sourceCharacter !== undefined; + } + ts.isSourceMapping = isSourceMapping; + function base64FormatEncode(value) { + return value >= 0 && value < 26 ? 65 + value : + value >= 26 && value < 52 ? 97 + value - 26 : + value >= 52 && value < 62 ? 48 + value - 52 : + value === 62 ? 43 : + value === 63 ? 47 : + ts.Debug.fail(value + ": not a base64 value"); + } + function base64FormatDecode(ch) { + return ch >= 65 && ch <= 90 ? ch - 65 : + ch >= 97 && ch <= 122 ? ch - 97 + 26 : + ch >= 48 && ch <= 57 ? ch - 48 + 52 : + ch === 43 ? 62 : + ch === 47 ? 63 : + -1; + } + function base64VLQFormatEncode(inValue) { + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } + else { + inValue = inValue << 1; + } + var encodedStr = ""; + do { + var currentDigit = inValue & 31; + inValue = inValue >> 5; + if (inValue > 0) { + currentDigit = currentDigit | 32; + } + encodedStr = encodedStr + String.fromCharCode(base64FormatEncode(currentDigit)); + } while (inValue > 0); + return encodedStr; + } + function isSourceMappedPosition(value) { + return value.sourceIndex !== undefined + && value.sourcePosition !== undefined; + } + function sameMappedPosition(left, right) { + return left.generatedPosition === right.generatedPosition + && left.sourceIndex === right.sourceIndex + && left.sourcePosition === right.sourcePosition; + } + function compareSourcePositions(left, right) { + ts.Debug.assert(left.sourceIndex === right.sourceIndex); + return ts.compareValues(left.sourcePosition, right.sourcePosition); + } + function compareGeneratedPositions(left, right) { + return ts.compareValues(left.generatedPosition, right.generatedPosition); + } + function getSourcePositionOfMapping(value) { + return value.sourcePosition; + } + function getGeneratedPositionOfMapping(value) { + return value.generatedPosition; + } + function createDocumentPositionMapper(host, map, mapPath) { + var mapDirectory = ts.getDirectoryPath(mapPath); + var sourceRoot = map.sourceRoot ? ts.getNormalizedAbsolutePath(map.sourceRoot, mapDirectory) : mapDirectory; + var generatedAbsoluteFilePath = ts.getNormalizedAbsolutePath(map.file, mapDirectory); + var generatedFile = host.getSourceFileLike(generatedAbsoluteFilePath); + var sourceFileAbsolutePaths = map.sources.map(function (source) { return ts.getNormalizedAbsolutePath(source, sourceRoot); }); + var sourceToSourceIndexMap = ts.createMapFromEntries(sourceFileAbsolutePaths.map(function (source, i) { return [host.getCanonicalFileName(source), i]; })); + var decodedMappings; + var generatedMappings; + var sourceMappings; + return { + getSourcePosition: getSourcePosition, + getGeneratedPosition: getGeneratedPosition + }; + function processMapping(mapping) { + var generatedPosition = generatedFile !== undefined + ? ts.getPositionOfLineAndCharacter(generatedFile, mapping.generatedLine, mapping.generatedCharacter, true) + : -1; + var source; + var sourcePosition; + if (isSourceMapping(mapping)) { + var sourceFile = host.getSourceFileLike(sourceFileAbsolutePaths[mapping.sourceIndex]); + source = map.sources[mapping.sourceIndex]; + sourcePosition = sourceFile !== undefined + ? ts.getPositionOfLineAndCharacter(sourceFile, mapping.sourceLine, mapping.sourceCharacter, true) + : -1; + } + return { + generatedPosition: generatedPosition, + source: source, + sourceIndex: mapping.sourceIndex, + sourcePosition: sourcePosition, + nameIndex: mapping.nameIndex + }; + } + function getDecodedMappings() { + if (decodedMappings === undefined) { + var decoder = decodeMappings(map.mappings); + var mappings = ts.arrayFrom(decoder, processMapping); + if (decoder.error !== undefined) { + if (host.log) { + host.log("Encountered error while decoding sourcemap: " + decoder.error); + } + decodedMappings = ts.emptyArray; + } + else { + decodedMappings = mappings; + } + } + return decodedMappings; + } + function getSourceMappings(sourceIndex) { + if (sourceMappings === undefined) { + var lists = []; + for (var _i = 0, _a = getDecodedMappings(); _i < _a.length; _i++) { + var mapping = _a[_i]; + if (!isSourceMappedPosition(mapping)) + continue; + var list = lists[mapping.sourceIndex]; + if (!list) + lists[mapping.sourceIndex] = list = []; + list.push(mapping); + } + sourceMappings = lists.map(function (list) { return ts.sortAndDeduplicate(list, compareSourcePositions, sameMappedPosition); }); + } + return sourceMappings[sourceIndex]; + } + function getGeneratedMappings() { + if (generatedMappings === undefined) { + var list = []; + for (var _i = 0, _a = getDecodedMappings(); _i < _a.length; _i++) { + var mapping = _a[_i]; + list.push(mapping); + } + generatedMappings = ts.sortAndDeduplicate(list, compareGeneratedPositions, sameMappedPosition); + } + return generatedMappings; + } + function getGeneratedPosition(loc) { + var sourceIndex = sourceToSourceIndexMap.get(host.getCanonicalFileName(loc.fileName)); + if (sourceIndex === undefined) + return loc; + var sourceMappings = getSourceMappings(sourceIndex); + if (!ts.some(sourceMappings)) + return loc; + var targetIndex = ts.binarySearchKey(sourceMappings, loc.pos, getSourcePositionOfMapping, ts.compareValues); + if (targetIndex < 0) { + targetIndex = ~targetIndex; + } + var mapping = sourceMappings[targetIndex]; + if (mapping === undefined || mapping.sourceIndex !== sourceIndex) { + return loc; + } + return { fileName: generatedAbsoluteFilePath, pos: mapping.generatedPosition }; + } + function getSourcePosition(loc) { + var generatedMappings = getGeneratedMappings(); + if (!ts.some(generatedMappings)) + return loc; + var targetIndex = ts.binarySearchKey(generatedMappings, loc.pos, getGeneratedPositionOfMapping, ts.compareValues); + if (targetIndex < 0) { + targetIndex = ~targetIndex; + } + var mapping = generatedMappings[targetIndex]; + if (mapping === undefined || !isSourceMappedPosition(mapping)) { + return loc; + } + return { fileName: sourceFileAbsolutePaths[mapping.sourceIndex], pos: mapping.sourcePosition }; + } + } + ts.createDocumentPositionMapper = createDocumentPositionMapper; + ts.identitySourceMapConsumer = { + getSourcePosition: ts.identity, + getGeneratedPosition: ts.identity + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function getOriginalNodeId(node) { + node = ts.getOriginalNode(node); + return node ? ts.getNodeId(node) : 0; + } + ts.getOriginalNodeId = getOriginalNodeId; + function containsDefaultReference(node) { + if (!node) + return false; + if (!ts.isNamedImports(node)) + return false; + return ts.some(node.elements, isNamedDefaultReference); + } + function isNamedDefaultReference(e) { + return e.propertyName !== undefined && e.propertyName.escapedText === "default"; + } + function chainBundle(transformSourceFile) { + return transformSourceFileOrBundle; + function transformSourceFileOrBundle(node) { + return node.kind === 290 ? transformSourceFile(node) : transformBundle(node); + } + function transformBundle(node) { + return ts.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends); + } + } + ts.chainBundle = chainBundle; + function getExportNeedsImportStarHelper(node) { + return !!ts.getNamespaceDeclarationNode(node); + } + ts.getExportNeedsImportStarHelper = getExportNeedsImportStarHelper; + function getImportNeedsImportStarHelper(node) { + if (!!ts.getNamespaceDeclarationNode(node)) { + return true; + } + var bindings = node.importClause && node.importClause.namedBindings; + if (!bindings) { + return false; + } + if (!ts.isNamedImports(bindings)) + return false; + var defaultRefCount = 0; + for (var _i = 0, _a = bindings.elements; _i < _a.length; _i++) { + var binding = _a[_i]; + if (isNamedDefaultReference(binding)) { + defaultRefCount++; + } + } + return (defaultRefCount > 0 && defaultRefCount !== bindings.elements.length) || (!!(bindings.elements.length - defaultRefCount) && ts.isDefaultImport(node)); + } + ts.getImportNeedsImportStarHelper = getImportNeedsImportStarHelper; + function getImportNeedsImportDefaultHelper(node) { + return !getImportNeedsImportStarHelper(node) && (ts.isDefaultImport(node) || (!!node.importClause && ts.isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings))); + } + ts.getImportNeedsImportDefaultHelper = getImportNeedsImportDefaultHelper; + function collectExternalModuleInfo(sourceFile, resolver, compilerOptions) { + var externalImports = []; + var exportSpecifiers = ts.createMultiMap(); + var exportedBindings = []; + var uniqueExports = ts.createMap(); + var exportedNames; + var hasExportDefault = false; + var exportEquals; + var hasExportStarsToExportValues = false; + var hasImportStar = false; + var hasImportDefault = false; + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var node = _a[_i]; + switch (node.kind) { + case 254: + externalImports.push(node); + if (!hasImportStar && getImportNeedsImportStarHelper(node)) { + hasImportStar = true; + } + if (!hasImportDefault && getImportNeedsImportDefaultHelper(node)) { + hasImportDefault = true; + } + break; + case 253: + if (node.moduleReference.kind === 265) { + externalImports.push(node); + } + break; + case 260: + if (node.moduleSpecifier) { + if (!node.exportClause) { + externalImports.push(node); + hasExportStarsToExportValues = true; + } + else { + externalImports.push(node); + } + } + else { + for (var _b = 0, _c = ts.cast(node.exportClause, ts.isNamedExports).elements; _b < _c.length; _b++) { + var specifier = _c[_b]; + if (!uniqueExports.get(ts.idText(specifier.name))) { + var name = specifier.propertyName || specifier.name; + exportSpecifiers.add(ts.idText(name), specifier); + var decl = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (decl) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name); + } + uniqueExports.set(ts.idText(specifier.name), true); + exportedNames = ts.append(exportedNames, specifier.name); + } + } + } + break; + case 259: + if (node.isExportEquals && !exportEquals) { + exportEquals = node; + } + break; + case 225: + if (ts.hasModifier(node, 1)) { + for (var _d = 0, _e = node.declarationList.declarations; _d < _e.length; _d++) { + var decl = _e[_d]; + exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames); + } + } + break; + case 244: + if (ts.hasModifier(node, 1)) { + if (ts.hasModifier(node, 512)) { + if (!hasExportDefault) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), ts.getDeclarationName(node)); + hasExportDefault = true; + } + } + else { + var name = node.name; + if (!uniqueExports.get(ts.idText(name))) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name); + uniqueExports.set(ts.idText(name), true); + exportedNames = ts.append(exportedNames, name); + } + } + } + break; + case 245: + if (ts.hasModifier(node, 1)) { + if (ts.hasModifier(node, 512)) { + if (!hasExportDefault) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), ts.getDeclarationName(node)); + hasExportDefault = true; + } + } + else { + var name = node.name; + if (name && !uniqueExports.get(ts.idText(name))) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name); + uniqueExports.set(ts.idText(name), true); + exportedNames = ts.append(exportedNames, name); + } + } + } + break; + } + } + var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault); + if (externalHelpersImportDeclaration) { + externalImports.unshift(externalHelpersImportDeclaration); + } + return { externalImports: externalImports, exportSpecifiers: exportSpecifiers, exportEquals: exportEquals, hasExportStarsToExportValues: hasExportStarsToExportValues, exportedBindings: exportedBindings, exportedNames: exportedNames, externalHelpersImportDeclaration: externalHelpersImportDeclaration }; + } + ts.collectExternalModuleInfo = collectExternalModuleInfo; + function collectExportedVariableInfo(decl, uniqueExports, exportedNames) { + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + exportedNames = collectExportedVariableInfo(element, uniqueExports, exportedNames); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + var text = ts.idText(decl.name); + if (!uniqueExports.get(text)) { + uniqueExports.set(text, true); + exportedNames = ts.append(exportedNames, decl.name); + } + } + return exportedNames; + } + function multiMapSparseArrayAdd(map, key, value) { + var values = map[key]; + if (values) { + values.push(value); + } + else { + map[key] = values = [value]; + } + return values; + } + function isSimpleCopiableExpression(expression) { + return ts.isStringLiteralLike(expression) || + expression.kind === 8 || + ts.isKeyword(expression.kind) || + ts.isIdentifier(expression); + } + ts.isSimpleCopiableExpression = isSimpleCopiableExpression; + function isSimpleInlineableExpression(expression) { + return !ts.isIdentifier(expression) && isSimpleCopiableExpression(expression) || + ts.isWellKnownSymbolSyntactically(expression); + } + ts.isSimpleInlineableExpression = isSimpleInlineableExpression; + function isCompoundAssignment(kind) { + return kind >= 63 + && kind <= 74; + } + ts.isCompoundAssignment = isCompoundAssignment; + function getNonAssignmentOperatorForCompoundAssignment(kind) { + switch (kind) { + case 63: return 39; + case 64: return 40; + case 65: return 41; + case 66: return 42; + case 67: return 43; + case 68: return 44; + case 69: return 47; + case 70: return 48; + case 71: return 49; + case 72: return 50; + case 73: return 51; + case 74: return 52; + } + } + ts.getNonAssignmentOperatorForCompoundAssignment = getNonAssignmentOperatorForCompoundAssignment; + function addPrologueDirectivesAndInitialSuperCall(ctor, result, visitor) { + if (ctor.body) { + var statements = ctor.body.statements; + var index = ts.addPrologue(result, statements, false, visitor); + if (index === statements.length) { + return index; + } + var superIndex = ts.findIndex(statements, function (s) { return ts.isExpressionStatement(s) && ts.isSuperCall(s.expression); }, index); + if (superIndex > -1) { + for (var i = index; i <= superIndex; i++) { + result.push(ts.visitNode(statements[i], visitor, ts.isStatement)); + } + return superIndex + 1; + } + return index; + } + return 0; + } + ts.addPrologueDirectivesAndInitialSuperCall = addPrologueDirectivesAndInitialSuperCall; + function helperString(input) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return function (uniqueName) { + var result = ""; + for (var i = 0; i < args.length; i++) { + result += input[i]; + result += uniqueName(args[i]); + } + result += input[input.length - 1]; + return result; + }; + } + ts.helperString = helperString; + function getProperties(node, requireInitializer, isStatic) { + return ts.filter(node.members, function (m) { return isInitializedOrStaticProperty(m, requireInitializer, isStatic); }); + } + ts.getProperties = getProperties; + function isInitializedOrStaticProperty(member, requireInitializer, isStatic) { + return ts.isPropertyDeclaration(member) + && (!!member.initializer || !requireInitializer) + && ts.hasStaticModifier(member) === isStatic; + } + function isInitializedProperty(member) { + return member.kind === 159 + && member.initializer !== undefined; + } + ts.isInitializedProperty = isInitializedProperty; +})(ts || (ts = {})); +var ts; +(function (ts) { + function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) { + var location = node; + var value; + if (ts.isDestructuringAssignment(node)) { + value = node.right; + while (ts.isEmptyArrayLiteral(node.left) || ts.isEmptyObjectLiteral(node.left)) { + if (ts.isDestructuringAssignment(value)) { + location = node = value; + value = node.right; + } + else { + return ts.visitNode(value, visitor, ts.isExpression); + } + } + } + var expressions; + var flattenContext = { + context: context, + level: level, + downlevelIteration: !!context.getCompilerOptions().downlevelIteration, + hoistTempVariables: true, + emitExpression: emitExpression, + emitBindingOrAssignment: emitBindingOrAssignment, + createArrayBindingOrAssignmentPattern: makeArrayAssignmentPattern, + createObjectBindingOrAssignmentPattern: makeObjectAssignmentPattern, + createArrayBindingOrAssignmentElement: makeAssignmentElement, + visitor: visitor + }; + if (value) { + value = ts.visitNode(value, visitor, ts.isExpression); + if (ts.isIdentifier(value) && bindingOrAssignmentElementAssignsToName(node, value.escapedText) || + bindingOrAssignmentElementContainsNonLiteralComputedName(node)) { + value = ensureIdentifier(flattenContext, value, false, location); + } + else if (needsValue) { + value = ensureIdentifier(flattenContext, value, true, location); + } + else if (ts.nodeIsSynthesized(node)) { + location = value; + } + } + flattenBindingOrAssignmentElement(flattenContext, node, value, location, ts.isDestructuringAssignment(node)); + if (value && needsValue) { + if (!ts.some(expressions)) { + return value; + } + expressions.push(value); + } + return ts.aggregateTransformFlags(ts.inlineExpressions(expressions)) || ts.createOmittedExpression(); + function emitExpression(expression) { + ts.setEmitFlags(expression, 64); + ts.aggregateTransformFlags(expression); + expressions = ts.append(expressions, expression); + } + function emitBindingOrAssignment(target, value, location, original) { + ts.Debug.assertNode(target, createAssignmentCallback ? ts.isIdentifier : ts.isExpression); + var expression = createAssignmentCallback + ? createAssignmentCallback(target, value, location) + : ts.setTextRange(ts.createAssignment(ts.visitNode(target, visitor, ts.isExpression), value), location); + expression.original = original; + emitExpression(expression); + } + } + ts.flattenDestructuringAssignment = flattenDestructuringAssignment; + function bindingOrAssignmentElementAssignsToName(element, escapedName) { + var target = ts.getTargetOfBindingOrAssignmentElement(element); + if (ts.isBindingOrAssignmentPattern(target)) { + return bindingOrAssignmentPatternAssignsToName(target, escapedName); + } + else if (ts.isIdentifier(target)) { + return target.escapedText === escapedName; + } + return false; + } + function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) { + var element = elements_3[_i]; + if (bindingOrAssignmentElementAssignsToName(element, escapedName)) { + return true; + } + } + return false; + } + function bindingOrAssignmentElementContainsNonLiteralComputedName(element) { + var propertyName = ts.tryGetPropertyNameOfBindingOrAssignmentElement(element); + if (propertyName && ts.isComputedPropertyName(propertyName) && !ts.isLiteralExpression(propertyName.expression)) { + return true; + } + var target = ts.getTargetOfBindingOrAssignmentElement(element); + return !!target && ts.isBindingOrAssignmentPattern(target) && bindingOrAssignmentPatternContainsNonLiteralComputedName(target); + } + function bindingOrAssignmentPatternContainsNonLiteralComputedName(pattern) { + return !!ts.forEach(ts.getElementsOfBindingOrAssignmentPattern(pattern), bindingOrAssignmentElementContainsNonLiteralComputedName); + } + function flattenDestructuringBinding(node, visitor, context, level, rval, hoistTempVariables, skipInitializer) { + if (hoistTempVariables === void 0) { hoistTempVariables = false; } + var pendingExpressions; + var pendingDeclarations = []; + var declarations = []; + var flattenContext = { + context: context, + level: level, + downlevelIteration: !!context.getCompilerOptions().downlevelIteration, + hoistTempVariables: hoistTempVariables, + emitExpression: emitExpression, + emitBindingOrAssignment: emitBindingOrAssignment, + createArrayBindingOrAssignmentPattern: makeArrayBindingPattern, + createObjectBindingOrAssignmentPattern: makeObjectBindingPattern, + createArrayBindingOrAssignmentElement: makeBindingElement, + visitor: visitor + }; + if (ts.isVariableDeclaration(node)) { + var initializer = ts.getInitializerOfBindingOrAssignmentElement(node); + if (initializer && (ts.isIdentifier(initializer) && bindingOrAssignmentElementAssignsToName(node, initializer.escapedText) || + bindingOrAssignmentElementContainsNonLiteralComputedName(node))) { + initializer = ensureIdentifier(flattenContext, initializer, false, initializer); + node = ts.updateVariableDeclaration(node, node.name, node.type, initializer); + } + } + flattenBindingOrAssignmentElement(flattenContext, node, rval, node, skipInitializer); + if (pendingExpressions) { + var temp = ts.createTempVariable(undefined); + if (hoistTempVariables) { + var value = ts.inlineExpressions(pendingExpressions); + pendingExpressions = undefined; + emitBindingOrAssignment(temp, value, undefined, undefined); + } + else { + context.hoistVariableDeclaration(temp); + var pendingDeclaration = ts.last(pendingDeclarations); + pendingDeclaration.pendingExpressions = ts.append(pendingDeclaration.pendingExpressions, ts.createAssignment(temp, pendingDeclaration.value)); + ts.addRange(pendingDeclaration.pendingExpressions, pendingExpressions); + pendingDeclaration.value = temp; + } + } + for (var _i = 0, pendingDeclarations_1 = pendingDeclarations; _i < pendingDeclarations_1.length; _i++) { + var _a = pendingDeclarations_1[_i], pendingExpressions_1 = _a.pendingExpressions, name = _a.name, value = _a.value, location = _a.location, original = _a.original; + var variable = ts.createVariableDeclaration(name, undefined, pendingExpressions_1 ? ts.inlineExpressions(ts.append(pendingExpressions_1, value)) : value); + variable.original = original; + ts.setTextRange(variable, location); + if (ts.isIdentifier(name)) { + ts.setEmitFlags(variable, 64); + } + ts.aggregateTransformFlags(variable); + declarations.push(variable); + } + return declarations; + function emitExpression(value) { + pendingExpressions = ts.append(pendingExpressions, value); + } + function emitBindingOrAssignment(target, value, location, original) { + ts.Debug.assertNode(target, ts.isBindingName); + if (pendingExpressions) { + value = ts.inlineExpressions(ts.append(pendingExpressions, value)); + pendingExpressions = undefined; + } + pendingDeclarations.push({ pendingExpressions: pendingExpressions, name: target, value: value, location: location, original: original }); + } + } + ts.flattenDestructuringBinding = flattenDestructuringBinding; + function flattenBindingOrAssignmentElement(flattenContext, element, value, location, skipInitializer) { + if (!skipInitializer) { + var initializer = ts.visitNode(ts.getInitializerOfBindingOrAssignmentElement(element), flattenContext.visitor, ts.isExpression); + if (initializer) { + value = value ? createDefaultValueCheck(flattenContext, value, initializer, location) : initializer; + } + else if (!value) { + value = ts.createVoidZero(); + } + } + var bindingTarget = ts.getTargetOfBindingOrAssignmentElement(element); + if (ts.isObjectBindingOrAssignmentPattern(bindingTarget)) { + flattenObjectBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location); + } + else if (ts.isArrayBindingOrAssignmentPattern(bindingTarget)) { + flattenArrayBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location); + } + else { + flattenContext.emitBindingOrAssignment(bindingTarget, value, location, element); + } + } + function flattenObjectBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + var numElements = elements.length; + if (numElements !== 1) { + var reuseIdentifierExpressions = !ts.isDeclarationBindingElement(parent) || numElements !== 0; + value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location); + } + var bindingElements; + var computedTempVariables; + for (var i = 0; i < numElements; i++) { + var element = elements[i]; + if (!ts.getRestIndicatorOfBindingOrAssignmentElement(element)) { + var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(element); + if (flattenContext.level >= 1 + && !(element.transformFlags & (8192 | 16384)) + && !(ts.getTargetOfBindingOrAssignmentElement(element).transformFlags & (8192 | 16384)) + && !ts.isComputedPropertyName(propertyName)) { + bindingElements = ts.append(bindingElements, ts.visitNode(element, flattenContext.visitor)); + } + else { + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + bindingElements = undefined; + } + var rhsValue = createDestructuringPropertyAccess(flattenContext, value, propertyName); + if (ts.isComputedPropertyName(propertyName)) { + computedTempVariables = ts.append(computedTempVariables, rhsValue.argumentExpression); + } + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element); + } + } + else if (i === numElements - 1) { + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + bindingElements = undefined; + } + var rhsValue = createRestCall(flattenContext.context, value, elements, computedTempVariables, pattern); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element); + } + } + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + } + } + function flattenArrayBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + var numElements = elements.length; + if (flattenContext.level < 1 && flattenContext.downlevelIteration) { + value = ensureIdentifier(flattenContext, ts.createReadHelper(flattenContext.context, value, numElements > 0 && ts.getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1]) + ? undefined + : numElements, location), false, location); + } + else if (numElements !== 1 && (flattenContext.level < 1 || numElements === 0) + || ts.every(elements, ts.isOmittedExpression)) { + var reuseIdentifierExpressions = !ts.isDeclarationBindingElement(parent) || numElements !== 0; + value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location); + } + var bindingElements; + var restContainingElements; + for (var i = 0; i < numElements; i++) { + var element = elements[i]; + if (flattenContext.level >= 1) { + if (element.transformFlags & 16384) { + var temp = ts.createTempVariable(undefined); + if (flattenContext.hoistTempVariables) { + flattenContext.context.hoistVariableDeclaration(temp); + } + restContainingElements = ts.append(restContainingElements, [temp, element]); + bindingElements = ts.append(bindingElements, flattenContext.createArrayBindingOrAssignmentElement(temp)); + } + else { + bindingElements = ts.append(bindingElements, element); + } + } + else if (ts.isOmittedExpression(element)) { + continue; + } + else if (!ts.getRestIndicatorOfBindingOrAssignmentElement(element)) { + var rhsValue = ts.createElementAccess(value, i); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element); + } + else if (i === numElements - 1) { + var rhsValue = ts.createArraySlice(value, i); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element); + } + } + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createArrayBindingOrAssignmentPattern(bindingElements), value, location, pattern); + } + if (restContainingElements) { + for (var _i = 0, restContainingElements_1 = restContainingElements; _i < restContainingElements_1.length; _i++) { + var _a = restContainingElements_1[_i], id = _a[0], element = _a[1]; + flattenBindingOrAssignmentElement(flattenContext, element, id, element); + } + } + } + function createDefaultValueCheck(flattenContext, value, defaultValue, location) { + value = ensureIdentifier(flattenContext, value, true, location); + return ts.createConditional(ts.createTypeCheck(value, "undefined"), defaultValue, value); + } + function createDestructuringPropertyAccess(flattenContext, value, propertyName) { + if (ts.isComputedPropertyName(propertyName)) { + var argumentExpression = ensureIdentifier(flattenContext, ts.visitNode(propertyName.expression, flattenContext.visitor), false, propertyName); + return ts.createElementAccess(value, argumentExpression); + } + else if (ts.isStringOrNumericLiteralLike(propertyName)) { + var argumentExpression = ts.getSynthesizedClone(propertyName); + argumentExpression.text = argumentExpression.text; + return ts.createElementAccess(value, argumentExpression); + } + else { + var name = ts.createIdentifier(ts.idText(propertyName)); + return ts.createPropertyAccess(value, name); + } + } + function ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location) { + if (ts.isIdentifier(value) && reuseIdentifierExpressions) { + return value; + } + else { + var temp = ts.createTempVariable(undefined); + if (flattenContext.hoistTempVariables) { + flattenContext.context.hoistVariableDeclaration(temp); + flattenContext.emitExpression(ts.setTextRange(ts.createAssignment(temp, value), location)); + } + else { + flattenContext.emitBindingOrAssignment(temp, value, location, undefined); + } + return temp; + } + } + function makeArrayBindingPattern(elements) { + ts.Debug.assertEachNode(elements, ts.isArrayBindingElement); + return ts.createArrayBindingPattern(elements); + } + function makeArrayAssignmentPattern(elements) { + return ts.createArrayLiteral(ts.map(elements, ts.convertToArrayAssignmentElement)); + } + function makeObjectBindingPattern(elements) { + ts.Debug.assertEachNode(elements, ts.isBindingElement); + return ts.createObjectBindingPattern(elements); + } + function makeObjectAssignmentPattern(elements) { + return ts.createObjectLiteral(ts.map(elements, ts.convertToObjectAssignmentElement)); + } + function makeBindingElement(name) { + return ts.createBindingElement(undefined, undefined, name); + } + function makeAssignmentElement(name) { + return name; + } + ts.restHelper = { + name: "typescript:rest", + importName: "__rest", + scoped: false, + text: "\n var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n };" + }; + function createRestCall(context, value, elements, computedTempVariables, location) { + context.requestEmitHelper(ts.restHelper); + var propertyNames = []; + var computedTempVariableOffset = 0; + for (var i = 0; i < elements.length - 1; i++) { + var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(elements[i]); + if (propertyName) { + if (ts.isComputedPropertyName(propertyName)) { + var temp = computedTempVariables[computedTempVariableOffset]; + computedTempVariableOffset++; + propertyNames.push(ts.createConditional(ts.createTypeCheck(temp, "symbol"), temp, ts.createAdd(temp, ts.createLiteral("")))); + } + else { + propertyNames.push(ts.createLiteral(propertyName)); + } + } + } + return ts.createCall(ts.getUnscopedHelperName("__rest"), undefined, [ + value, + ts.setTextRange(ts.createArrayLiteral(propertyNames), location) + ]); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var USE_NEW_TYPE_METADATA_FORMAT = false; + function transformTypeScript(context) { + var startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks"); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.enableSubstitution(194); + context.enableSubstitution(195); + var currentSourceFile; + var currentNamespace; + var currentNamespaceContainerName; + var currentLexicalScope; + var currentNameScope; + var currentScopeFirstDeclarationsOfName; + var currentClassHasParameterProperties; + var enabledSubstitutions; + var classAliases; + var applicableSubstitutions; + return transformSourceFileOrBundle; + function transformSourceFileOrBundle(node) { + if (node.kind === 291) { + return transformBundle(node); + } + return transformSourceFile(node); + } + function transformBundle(node) { + return ts.createBundle(node.sourceFiles.map(transformSourceFile), ts.mapDefined(node.prepends, function (prepend) { + if (prepend.kind === 293) { + return ts.createUnparsedSourceFile(prepend, "js"); + } + return prepend; + })); + } + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + var visited = saveStateAndInvoke(node, visitSourceFile); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + currentSourceFile = undefined; + return visited; + } + function saveStateAndInvoke(node, f) { + var savedCurrentScope = currentLexicalScope; + var savedCurrentNameScope = currentNameScope; + var savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName; + var savedCurrentClassHasParameterProperties = currentClassHasParameterProperties; + onBeforeVisitNode(node); + var visited = f(node); + if (currentLexicalScope !== savedCurrentScope) { + currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName; + } + currentLexicalScope = savedCurrentScope; + currentNameScope = savedCurrentNameScope; + currentClassHasParameterProperties = savedCurrentClassHasParameterProperties; + return visited; + } + function onBeforeVisitNode(node) { + switch (node.kind) { + case 290: + case 251: + case 250: + case 223: + currentLexicalScope = node; + currentNameScope = undefined; + currentScopeFirstDeclarationsOfName = undefined; + break; + case 245: + case 244: + if (ts.hasModifier(node, 2)) { + break; + } + if (node.name) { + recordEmittedDeclarationInScope(node); + } + else { + ts.Debug.assert(node.kind === 245 || ts.hasModifier(node, 512)); + } + if (ts.isClassDeclaration(node)) { + currentNameScope = node; + } + break; + } + } + function visitor(node) { + return saveStateAndInvoke(node, visitorWorker); + } + function visitorWorker(node) { + if (node.transformFlags & 1) { + return visitTypeScript(node); + } + return node; + } + function sourceElementVisitor(node) { + return saveStateAndInvoke(node, sourceElementVisitorWorker); + } + function sourceElementVisitorWorker(node) { + switch (node.kind) { + case 254: + case 253: + case 259: + case 260: + return visitEllidableStatement(node); + default: + return visitorWorker(node); + } + } + function visitEllidableStatement(node) { + var parsed = ts.getParseTreeNode(node); + if (parsed !== node) { + if (node.transformFlags & 1) { + return ts.visitEachChild(node, visitor, context); + } + return node; + } + switch (node.kind) { + case 254: + return visitImportDeclaration(node); + case 253: + return visitImportEqualsDeclaration(node); + case 259: + return visitExportAssignment(node); + case 260: + return visitExportDeclaration(node); + default: + ts.Debug.fail("Unhandled ellided statement"); + } + } + function namespaceElementVisitor(node) { + return saveStateAndInvoke(node, namespaceElementVisitorWorker); + } + function namespaceElementVisitorWorker(node) { + if (node.kind === 260 || + node.kind === 254 || + node.kind === 255 || + (node.kind === 253 && + node.moduleReference.kind === 265)) { + return undefined; + } + else if (node.transformFlags & 1 || ts.hasModifier(node, 1)) { + return visitTypeScript(node); + } + return node; + } + function classElementVisitor(node) { + return saveStateAndInvoke(node, classElementVisitorWorker); + } + function classElementVisitorWorker(node) { + switch (node.kind) { + case 162: + return visitConstructor(node); + case 159: + return visitPropertyDeclaration(node); + case 167: + case 163: + case 164: + case 161: + return visitorWorker(node); + case 222: + return node; + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function modifierVisitor(node) { + if (ts.modifierToFlag(node.kind) & 2270) { + return undefined; + } + else if (currentNamespace && node.kind === 89) { + return undefined; + } + return node; + } + function visitTypeScript(node) { + if (ts.isStatement(node) && ts.hasModifier(node, 2)) { + return ts.createNotEmittedStatement(node); + } + switch (node.kind) { + case 89: + case 84: + return currentNamespace ? undefined : node; + case 119: + case 117: + case 118: + case 122: + case 81: + case 130: + case 138: + case 174: + case 175: + case 176: + case 177: + case 173: + case 168: + case 155: + case 125: + case 148: + case 128: + case 143: + case 140: + case 137: + case 110: + case 144: + case 171: + case 170: + case 172: + case 169: + case 178: + case 179: + case 180: + case 182: + case 183: + case 184: + case 185: + case 186: + case 187: + case 167: + case 157: + case 247: + return undefined; + case 159: + return visitPropertyDeclaration(node); + case 252: + return undefined; + case 162: + return visitConstructor(node); + case 246: + return ts.createNotEmittedStatement(node); + case 245: + return visitClassDeclaration(node); + case 214: + return visitClassExpression(node); + case 279: + return visitHeritageClause(node); + case 216: + return visitExpressionWithTypeArguments(node); + case 161: + return visitMethodDeclaration(node); + case 163: + return visitGetAccessor(node); + case 164: + return visitSetAccessor(node); + case 244: + return visitFunctionDeclaration(node); + case 201: + return visitFunctionExpression(node); + case 202: + return visitArrowFunction(node); + case 156: + return visitParameter(node); + case 200: + return visitParenthesizedExpression(node); + case 199: + case 217: + return visitAssertionExpression(node); + case 196: + return visitCallExpression(node); + case 197: + return visitNewExpression(node); + case 198: + return visitTaggedTemplateExpression(node); + case 218: + return visitNonNullExpression(node); + case 248: + return visitEnumDeclaration(node); + case 225: + return visitVariableStatement(node); + case 242: + return visitVariableDeclaration(node); + case 249: + return visitModuleDeclaration(node); + case 253: + return visitImportEqualsDeclaration(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitSourceFile(node) { + var alwaysStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") && + !(ts.isExternalModule(node) && moduleKind >= ts.ModuleKind.ES2015) && + !ts.isJsonSourceFile(node); + return ts.updateSourceFileNode(node, ts.visitLexicalEnvironment(node.statements, sourceElementVisitor, context, 0, alwaysStrict)); + } + function shouldEmitDecorateCallForClass(node) { + if (node.decorators && node.decorators.length > 0) { + return true; + } + var constructor = ts.getFirstConstructorWithBody(node); + if (constructor) { + return ts.forEach(constructor.parameters, shouldEmitDecorateCallForParameter); + } + return false; + } + function shouldEmitDecorateCallForParameter(parameter) { + return parameter.decorators !== undefined && parameter.decorators.length > 0; + } + function getClassFacts(node, staticProperties) { + var facts = 0; + if (ts.some(staticProperties)) + facts |= 1; + var extendsClauseElement = ts.getEffectiveBaseTypeNode(node); + if (extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100) + facts |= 64; + if (shouldEmitDecorateCallForClass(node)) + facts |= 2; + if (ts.childIsDecorated(node)) + facts |= 4; + if (isExportOfNamespace(node)) + facts |= 8; + else if (isDefaultExternalModuleExport(node)) + facts |= 32; + else if (isNamedExternalModuleExport(node)) + facts |= 16; + if (languageVersion <= 1 && (facts & 7)) + facts |= 128; + return facts; + } + function hasTypeScriptClassSyntax(node) { + return !!(node.transformFlags & 2048); + } + function isClassLikeDeclarationWithTypeScriptSyntax(node) { + return ts.some(node.decorators) + || ts.some(node.typeParameters) + || ts.some(node.heritageClauses, hasTypeScriptClassSyntax) + || ts.some(node.members, hasTypeScriptClassSyntax); + } + function visitClassDeclaration(node) { + if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && ts.hasModifier(node, 1))) { + return ts.visitEachChild(node, visitor, context); + } + var staticProperties = ts.getProperties(node, true, true); + var facts = getClassFacts(node, staticProperties); + if (facts & 128) { + context.startLexicalEnvironment(); + } + var name = node.name || (facts & 5 ? ts.getGeneratedNameForNode(node) : undefined); + var classStatement = facts & 2 + ? createClassDeclarationHeadWithDecorators(node, name) + : createClassDeclarationHeadWithoutDecorators(node, name, facts); + var statements = [classStatement]; + addClassElementDecorationStatements(statements, node, false); + addClassElementDecorationStatements(statements, node, true); + addConstructorDecorationStatement(statements, node); + if (facts & 128) { + var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentSourceFile.text, node.members.end), 19); + var localName = ts.getInternalName(node); + var outer = ts.createPartiallyEmittedExpression(localName); + outer.end = closingBraceLocation.end; + ts.setEmitFlags(outer, 1536); + var statement = ts.createReturn(outer); + statement.pos = closingBraceLocation.pos; + ts.setEmitFlags(statement, 1536 | 384); + statements.push(statement); + ts.insertStatementsAfterStandardPrologue(statements, context.endLexicalEnvironment()); + var iife = ts.createImmediatelyInvokedArrowFunction(statements); + ts.setEmitFlags(iife, 33554432); + var varStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.getLocalName(node, false, false), undefined, iife) + ])); + ts.setOriginalNode(varStatement, node); + ts.setCommentRange(varStatement, node); + ts.setSourceMapRange(varStatement, ts.moveRangePastDecorators(node)); + ts.startOnNewLine(varStatement); + statements = [varStatement]; + } + if (facts & 8) { + addExportMemberAssignment(statements, node); + } + else if (facts & 128 || facts & 2) { + if (facts & 32) { + statements.push(ts.createExportDefault(ts.getLocalName(node, false, true))); + } + else if (facts & 16) { + statements.push(ts.createExternalModuleExport(ts.getLocalName(node, false, true))); + } + } + if (statements.length > 1) { + statements.push(ts.createEndOfDeclarationMarker(node)); + ts.setEmitFlags(classStatement, ts.getEmitFlags(classStatement) | 4194304); + } + return ts.singleOrMany(statements); + } + function createClassDeclarationHeadWithoutDecorators(node, name, facts) { + var modifiers = !(facts & 128) + ? ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier) + : undefined; + var classDeclaration = ts.createClassDeclaration(undefined, modifiers, name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node)); + var emitFlags = ts.getEmitFlags(node); + if (facts & 1) { + emitFlags |= 32; + } + ts.aggregateTransformFlags(classDeclaration); + ts.setTextRange(classDeclaration, node); + ts.setOriginalNode(classDeclaration, node); + ts.setEmitFlags(classDeclaration, emitFlags); + return classDeclaration; + } + function createClassDeclarationHeadWithDecorators(node, name) { + var location = ts.moveRangePastDecorators(node); + var classAlias = getClassAliasIfNeeded(node); + var declName = ts.getLocalName(node, false, true); + var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause); + var members = transformClassMembers(node); + var classExpression = ts.createClassExpression(undefined, name, undefined, heritageClauses, members); + ts.aggregateTransformFlags(classExpression); + ts.setOriginalNode(classExpression, node); + ts.setTextRange(classExpression, location); + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(declName, undefined, classAlias ? ts.createAssignment(classAlias, classExpression) : classExpression) + ], 1)); + ts.setOriginalNode(statement, node); + ts.setTextRange(statement, location); + ts.setCommentRange(statement, node); + return statement; + } + function visitClassExpression(node) { + if (!isClassLikeDeclarationWithTypeScriptSyntax(node)) { + return ts.visitEachChild(node, visitor, context); + } + var classExpression = ts.createClassExpression(undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node)); + ts.aggregateTransformFlags(classExpression); + ts.setOriginalNode(classExpression, node); + ts.setTextRange(classExpression, node); + return classExpression; + } + function transformClassMembers(node) { + var members = []; + var constructor = ts.getFirstConstructorWithBody(node); + var parametersWithPropertyAssignments = constructor && + ts.filter(constructor.parameters, function (p) { return ts.isParameterPropertyDeclaration(p, constructor); }); + if (parametersWithPropertyAssignments) { + for (var _i = 0, parametersWithPropertyAssignments_1 = parametersWithPropertyAssignments; _i < parametersWithPropertyAssignments_1.length; _i++) { + var parameter = parametersWithPropertyAssignments_1[_i]; + if (ts.isIdentifier(parameter.name)) { + members.push(ts.setOriginalNode(ts.aggregateTransformFlags(ts.createProperty(undefined, undefined, parameter.name, undefined, undefined, undefined)), parameter)); + } + } + } + ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement)); + return ts.setTextRange(ts.createNodeArray(members), node.members); + } + function getDecoratedClassElements(node, isStatic) { + return ts.filter(node.members, isStatic ? function (m) { return isStaticDecoratedClassElement(m, node); } : function (m) { return isInstanceDecoratedClassElement(m, node); }); + } + function isStaticDecoratedClassElement(member, parent) { + return isDecoratedClassElement(member, true, parent); + } + function isInstanceDecoratedClassElement(member, parent) { + return isDecoratedClassElement(member, false, parent); + } + function isDecoratedClassElement(member, isStatic, parent) { + return ts.nodeOrChildIsDecorated(member, parent) + && isStatic === ts.hasModifier(member, 32); + } + function getDecoratorsOfParameters(node) { + var decorators; + if (node) { + var parameters = node.parameters; + var firstParameterIsThis = parameters.length > 0 && ts.parameterIsThisKeyword(parameters[0]); + var firstParameterOffset = firstParameterIsThis ? 1 : 0; + var numParameters = firstParameterIsThis ? parameters.length - 1 : parameters.length; + for (var i = 0; i < numParameters; i++) { + var parameter = parameters[i + firstParameterOffset]; + if (decorators || parameter.decorators) { + if (!decorators) { + decorators = new Array(numParameters); + } + decorators[i] = parameter.decorators; + } + } + } + return decorators; + } + function getAllDecoratorsOfConstructor(node) { + var decorators = node.decorators; + var parameters = getDecoratorsOfParameters(ts.getFirstConstructorWithBody(node)); + if (!decorators && !parameters) { + return undefined; + } + return { + decorators: decorators, + parameters: parameters + }; + } + function getAllDecoratorsOfClassElement(node, member) { + switch (member.kind) { + case 163: + case 164: + return getAllDecoratorsOfAccessors(node, member); + case 161: + return getAllDecoratorsOfMethod(member); + case 159: + return getAllDecoratorsOfProperty(member); + default: + return undefined; + } + } + function getAllDecoratorsOfAccessors(node, accessor) { + if (!accessor.body) { + return undefined; + } + var _a = ts.getAllAccessorDeclarations(node.members, accessor), firstAccessor = _a.firstAccessor, secondAccessor = _a.secondAccessor, setAccessor = _a.setAccessor; + var firstAccessorWithDecorators = firstAccessor.decorators ? firstAccessor : secondAccessor && secondAccessor.decorators ? secondAccessor : undefined; + if (!firstAccessorWithDecorators || accessor !== firstAccessorWithDecorators) { + return undefined; + } + var decorators = firstAccessorWithDecorators.decorators; + var parameters = getDecoratorsOfParameters(setAccessor); + if (!decorators && !parameters) { + return undefined; + } + return { decorators: decorators, parameters: parameters }; + } + function getAllDecoratorsOfMethod(method) { + if (!method.body) { + return undefined; + } + var decorators = method.decorators; + var parameters = getDecoratorsOfParameters(method); + if (!decorators && !parameters) { + return undefined; + } + return { decorators: decorators, parameters: parameters }; + } + function getAllDecoratorsOfProperty(property) { + var decorators = property.decorators; + if (!decorators) { + return undefined; + } + return { decorators: decorators }; + } + function transformAllDecoratorsOfDeclaration(node, container, allDecorators) { + if (!allDecorators) { + return undefined; + } + var decoratorExpressions = []; + ts.addRange(decoratorExpressions, ts.map(allDecorators.decorators, transformDecorator)); + ts.addRange(decoratorExpressions, ts.flatMap(allDecorators.parameters, transformDecoratorsOfParameter)); + addTypeMetadata(node, container, decoratorExpressions); + return decoratorExpressions; + } + function addClassElementDecorationStatements(statements, node, isStatic) { + ts.addRange(statements, ts.map(generateClassElementDecorationExpressions(node, isStatic), expressionToStatement)); + } + function generateClassElementDecorationExpressions(node, isStatic) { + var members = getDecoratedClassElements(node, isStatic); + var expressions; + for (var _i = 0, members_6 = members; _i < members_6.length; _i++) { + var member = members_6[_i]; + var expression = generateClassElementDecorationExpression(node, member); + if (expression) { + if (!expressions) { + expressions = [expression]; + } + else { + expressions.push(expression); + } + } + } + return expressions; + } + function generateClassElementDecorationExpression(node, member) { + var allDecorators = getAllDecoratorsOfClassElement(node, member); + var decoratorExpressions = transformAllDecoratorsOfDeclaration(member, node, allDecorators); + if (!decoratorExpressions) { + return undefined; + } + var prefix = getClassMemberPrefix(node, member); + var memberName = getExpressionForPropertyName(member, true); + var descriptor = languageVersion > 0 + ? member.kind === 159 + ? ts.createVoidZero() + : ts.createNull() + : undefined; + var helper = createDecorateHelper(context, decoratorExpressions, prefix, memberName, descriptor, ts.moveRangePastDecorators(member)); + ts.setEmitFlags(helper, 1536); + return helper; + } + function addConstructorDecorationStatement(statements, node) { + var expression = generateConstructorDecorationExpression(node); + if (expression) { + statements.push(ts.setOriginalNode(ts.createExpressionStatement(expression), node)); + } + } + function generateConstructorDecorationExpression(node) { + var allDecorators = getAllDecoratorsOfConstructor(node); + var decoratorExpressions = transformAllDecoratorsOfDeclaration(node, node, allDecorators); + if (!decoratorExpressions) { + return undefined; + } + var classAlias = classAliases && classAliases[ts.getOriginalNodeId(node)]; + var localName = ts.getLocalName(node, false, true); + var decorate = createDecorateHelper(context, decoratorExpressions, localName); + var expression = ts.createAssignment(localName, classAlias ? ts.createAssignment(classAlias, decorate) : decorate); + ts.setEmitFlags(expression, 1536); + ts.setSourceMapRange(expression, ts.moveRangePastDecorators(node)); + return expression; + } + function transformDecorator(decorator) { + return ts.visitNode(decorator.expression, visitor, ts.isExpression); + } + function transformDecoratorsOfParameter(decorators, parameterOffset) { + var expressions; + if (decorators) { + expressions = []; + for (var _i = 0, decorators_1 = decorators; _i < decorators_1.length; _i++) { + var decorator = decorators_1[_i]; + var helper = createParamHelper(context, transformDecorator(decorator), parameterOffset, decorator.expression); + ts.setEmitFlags(helper, 1536); + expressions.push(helper); + } + } + return expressions; + } + function addTypeMetadata(node, container, decoratorExpressions) { + if (USE_NEW_TYPE_METADATA_FORMAT) { + addNewTypeMetadata(node, container, decoratorExpressions); + } + else { + addOldTypeMetadata(node, container, decoratorExpressions); + } + } + function addOldTypeMetadata(node, container, decoratorExpressions) { + if (compilerOptions.emitDecoratorMetadata) { + if (shouldAddTypeMetadata(node)) { + decoratorExpressions.push(createMetadataHelper(context, "design:type", serializeTypeOfNode(node))); + } + if (shouldAddParamTypesMetadata(node)) { + decoratorExpressions.push(createMetadataHelper(context, "design:paramtypes", serializeParameterTypesOfNode(node, container))); + } + if (shouldAddReturnTypeMetadata(node)) { + decoratorExpressions.push(createMetadataHelper(context, "design:returntype", serializeReturnTypeOfNode(node))); + } + } + } + function addNewTypeMetadata(node, container, decoratorExpressions) { + if (compilerOptions.emitDecoratorMetadata) { + var properties = void 0; + if (shouldAddTypeMetadata(node)) { + (properties || (properties = [])).push(ts.createPropertyAssignment("type", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeTypeOfNode(node)))); + } + if (shouldAddParamTypesMetadata(node)) { + (properties || (properties = [])).push(ts.createPropertyAssignment("paramTypes", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeParameterTypesOfNode(node, container)))); + } + if (shouldAddReturnTypeMetadata(node)) { + (properties || (properties = [])).push(ts.createPropertyAssignment("returnType", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeReturnTypeOfNode(node)))); + } + if (properties) { + decoratorExpressions.push(createMetadataHelper(context, "design:typeinfo", ts.createObjectLiteral(properties, true))); + } + } + } + function shouldAddTypeMetadata(node) { + var kind = node.kind; + return kind === 161 + || kind === 163 + || kind === 164 + || kind === 159; + } + function shouldAddReturnTypeMetadata(node) { + return node.kind === 161; + } + function shouldAddParamTypesMetadata(node) { + switch (node.kind) { + case 245: + case 214: + return ts.getFirstConstructorWithBody(node) !== undefined; + case 161: + case 163: + case 164: + return true; + } + return false; + } + function getAccessorTypeNode(node) { + var accessors = resolver.getAllAccessorDeclarations(node); + return accessors.setAccessor && ts.getSetAccessorTypeAnnotationNode(accessors.setAccessor) + || accessors.getAccessor && ts.getEffectiveReturnTypeNode(accessors.getAccessor); + } + function serializeTypeOfNode(node) { + switch (node.kind) { + case 159: + case 156: + return serializeTypeNode(node.type); + case 164: + case 163: + return serializeTypeNode(getAccessorTypeNode(node)); + case 245: + case 214: + case 161: + return ts.createIdentifier("Function"); + default: + return ts.createVoidZero(); + } + } + function serializeParameterTypesOfNode(node, container) { + var valueDeclaration = ts.isClassLike(node) + ? ts.getFirstConstructorWithBody(node) + : ts.isFunctionLike(node) && ts.nodeIsPresent(node.body) + ? node + : undefined; + var expressions = []; + if (valueDeclaration) { + var parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container); + var numParameters = parameters.length; + for (var i = 0; i < numParameters; i++) { + var parameter = parameters[i]; + if (i === 0 && ts.isIdentifier(parameter.name) && parameter.name.escapedText === "this") { + continue; + } + if (parameter.dotDotDotToken) { + expressions.push(serializeTypeNode(ts.getRestParameterElementType(parameter.type))); + } + else { + expressions.push(serializeTypeOfNode(parameter)); + } + } + } + return ts.createArrayLiteral(expressions); + } + function getParametersOfDecoratedDeclaration(node, container) { + if (container && node.kind === 163) { + var setAccessor = ts.getAllAccessorDeclarations(container.members, node).setAccessor; + if (setAccessor) { + return setAccessor.parameters; + } + } + return node.parameters; + } + function serializeReturnTypeOfNode(node) { + if (ts.isFunctionLike(node) && node.type) { + return serializeTypeNode(node.type); + } + else if (ts.isAsyncFunction(node)) { + return ts.createIdentifier("Promise"); + } + return ts.createVoidZero(); + } + function serializeTypeNode(node) { + if (node === undefined) { + return ts.createIdentifier("Object"); + } + switch (node.kind) { + case 110: + case 146: + case 100: + case 137: + return ts.createVoidZero(); + case 182: + return serializeTypeNode(node.type); + case 170: + case 171: + return ts.createIdentifier("Function"); + case 174: + case 175: + return ts.createIdentifier("Array"); + case 168: + case 128: + return ts.createIdentifier("Boolean"); + case 143: + return ts.createIdentifier("String"); + case 141: + return ts.createIdentifier("Object"); + case 187: + switch (node.literal.kind) { + case 10: + return ts.createIdentifier("String"); + case 207: + case 8: + return ts.createIdentifier("Number"); + case 9: + return getGlobalBigIntNameWithFallback(); + case 106: + case 91: + return ts.createIdentifier("Boolean"); + default: + return ts.Debug.failBadSyntaxKind(node.literal); + } + case 140: + return ts.createIdentifier("Number"); + case 151: + return getGlobalBigIntNameWithFallback(); + case 144: + return languageVersion < 2 + ? getGlobalSymbolNameWithFallback() + : ts.createIdentifier("Symbol"); + case 169: + return serializeTypeReferenceNode(node); + case 179: + case 178: + return serializeTypeList(node.types); + case 180: + return serializeTypeList([node.trueType, node.falseType]); + case 184: + if (node.operator === 138) { + return serializeTypeNode(node.type); + } + break; + case 172: + case 185: + case 186: + case 173: + case 125: + case 148: + case 183: + case 188: + break; + default: + return ts.Debug.failBadSyntaxKind(node); + } + return ts.createIdentifier("Object"); + } + function serializeTypeList(types) { + var serializedUnion; + for (var _i = 0, types_20 = types; _i < types_20.length; _i++) { + var typeNode = types_20[_i]; + while (typeNode.kind === 182) { + typeNode = typeNode.type; + } + if (typeNode.kind === 137) { + continue; + } + if (!strictNullChecks && (typeNode.kind === 100 || typeNode.kind === 146)) { + continue; + } + var serializedIndividual = serializeTypeNode(typeNode); + if (ts.isIdentifier(serializedIndividual) && serializedIndividual.escapedText === "Object") { + return serializedIndividual; + } + else if (serializedUnion) { + if (!ts.isIdentifier(serializedUnion) || + !ts.isIdentifier(serializedIndividual) || + serializedUnion.escapedText !== serializedIndividual.escapedText) { + return ts.createIdentifier("Object"); + } + } + else { + serializedUnion = serializedIndividual; + } + } + return serializedUnion || ts.createVoidZero(); + } + function serializeTypeReferenceNode(node) { + var kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope || currentLexicalScope); + switch (kind) { + case ts.TypeReferenceSerializationKind.Unknown: + if (ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n); })) { + return ts.createIdentifier("Object"); + } + var serialized = serializeEntityNameAsExpressionFallback(node.typeName); + var temp = ts.createTempVariable(hoistVariableDeclaration); + return ts.createConditional(ts.createTypeCheck(ts.createAssignment(temp, serialized), "function"), temp, ts.createIdentifier("Object")); + case ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue: + return serializeEntityNameAsExpression(node.typeName); + case ts.TypeReferenceSerializationKind.VoidNullableOrNeverType: + return ts.createVoidZero(); + case ts.TypeReferenceSerializationKind.BigIntLikeType: + return getGlobalBigIntNameWithFallback(); + case ts.TypeReferenceSerializationKind.BooleanType: + return ts.createIdentifier("Boolean"); + case ts.TypeReferenceSerializationKind.NumberLikeType: + return ts.createIdentifier("Number"); + case ts.TypeReferenceSerializationKind.StringLikeType: + return ts.createIdentifier("String"); + case ts.TypeReferenceSerializationKind.ArrayLikeType: + return ts.createIdentifier("Array"); + case ts.TypeReferenceSerializationKind.ESSymbolType: + return languageVersion < 2 + ? getGlobalSymbolNameWithFallback() + : ts.createIdentifier("Symbol"); + case ts.TypeReferenceSerializationKind.TypeWithCallSignature: + return ts.createIdentifier("Function"); + case ts.TypeReferenceSerializationKind.Promise: + return ts.createIdentifier("Promise"); + case ts.TypeReferenceSerializationKind.ObjectType: + return ts.createIdentifier("Object"); + default: + return ts.Debug.assertNever(kind); + } + } + function createCheckedValue(left, right) { + return ts.createLogicalAnd(ts.createStrictInequality(ts.createTypeOf(left), ts.createLiteral("undefined")), right); + } + function serializeEntityNameAsExpressionFallback(node) { + if (node.kind === 75) { + var copied = serializeEntityNameAsExpression(node); + return createCheckedValue(copied, copied); + } + if (node.left.kind === 75) { + return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node)); + } + var left = serializeEntityNameAsExpressionFallback(node.left); + var temp = ts.createTempVariable(hoistVariableDeclaration); + return ts.createLogicalAnd(ts.createLogicalAnd(left.left, ts.createStrictInequality(ts.createAssignment(temp, left.right), ts.createVoidZero())), ts.createPropertyAccess(temp, node.right)); + } + function serializeEntityNameAsExpression(node) { + switch (node.kind) { + case 75: + var name = ts.getMutableClone(node); + name.flags &= ~8; + name.original = undefined; + name.parent = ts.getParseTreeNode(currentLexicalScope); + return name; + case 153: + return serializeQualifiedNameAsExpression(node); + } + } + function serializeQualifiedNameAsExpression(node) { + return ts.createPropertyAccess(serializeEntityNameAsExpression(node.left), node.right); + } + function getGlobalSymbolNameWithFallback() { + return ts.createConditional(ts.createTypeCheck(ts.createIdentifier("Symbol"), "function"), ts.createIdentifier("Symbol"), ts.createIdentifier("Object")); + } + function getGlobalBigIntNameWithFallback() { + return languageVersion < 99 + ? ts.createConditional(ts.createTypeCheck(ts.createIdentifier("BigInt"), "function"), ts.createIdentifier("BigInt"), ts.createIdentifier("Object")) + : ts.createIdentifier("BigInt"); + } + function getExpressionForPropertyName(member, generateNameForComputedPropertyName) { + var name = member.name; + if (ts.isPrivateIdentifier(name)) { + return ts.createIdentifier(""); + } + else if (ts.isComputedPropertyName(name)) { + return generateNameForComputedPropertyName && !ts.isSimpleInlineableExpression(name.expression) + ? ts.getGeneratedNameForNode(name) + : name.expression; + } + else if (ts.isIdentifier(name)) { + return ts.createLiteral(ts.idText(name)); + } + else { + return ts.getSynthesizedClone(name); + } + } + function visitPropertyNameOfClassElement(member) { + var name = member.name; + if (ts.isComputedPropertyName(name) && ((!ts.hasStaticModifier(member) && currentClassHasParameterProperties) || ts.some(member.decorators))) { + var expression = ts.visitNode(name.expression, visitor, ts.isExpression); + var innerExpression = ts.skipPartiallyEmittedExpressions(expression); + if (!ts.isSimpleInlineableExpression(innerExpression)) { + var generatedName = ts.getGeneratedNameForNode(name); + hoistVariableDeclaration(generatedName); + return ts.updateComputedPropertyName(name, ts.createAssignment(generatedName, expression)); + } + } + return ts.visitNode(name, visitor, ts.isPropertyName); + } + function visitHeritageClause(node) { + if (node.token === 113) { + return undefined; + } + return ts.visitEachChild(node, visitor, context); + } + function visitExpressionWithTypeArguments(node) { + return ts.updateExpressionWithTypeArguments(node, undefined, ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)); + } + function shouldEmitFunctionLikeDeclaration(node) { + return !ts.nodeIsMissing(node.body); + } + function visitPropertyDeclaration(node) { + if (node.flags & 8388608) { + return undefined; + } + var updated = ts.updateProperty(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitNode(node.initializer, visitor)); + if (updated !== node) { + ts.setCommentRange(updated, node); + ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node)); + } + return updated; + } + function visitConstructor(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return undefined; + } + return ts.updateConstructor(node, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), transformConstructorBody(node.body, node)); + } + function transformConstructorBody(body, constructor) { + var parametersWithPropertyAssignments = constructor && + ts.filter(constructor.parameters, function (p) { return ts.isParameterPropertyDeclaration(p, constructor); }); + if (!ts.some(parametersWithPropertyAssignments)) { + return ts.visitFunctionBody(body, visitor, context); + } + var statements = []; + var indexOfFirstStatement = 0; + resumeLexicalEnvironment(); + indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor); + ts.addRange(statements, ts.map(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment)); + ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexOfFirstStatement)); + statements = ts.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), body.statements), true); + ts.setTextRange(block, body); + ts.setOriginalNode(block, body); + return block; + } + function transformParameterWithPropertyAssignment(node) { + var name = node.name; + if (!ts.isIdentifier(name)) { + return undefined; + } + var propertyName = ts.getMutableClone(name); + ts.setEmitFlags(propertyName, 1536 | 48); + var localName = ts.getMutableClone(name); + ts.setEmitFlags(localName, 1536); + return ts.startOnNewLine(ts.removeAllComments(ts.setTextRange(ts.setOriginalNode(ts.createExpressionStatement(ts.createAssignment(ts.setTextRange(ts.createPropertyAccess(ts.createThis(), propertyName), node.name), localName)), node), ts.moveRangePos(node, -1)))); + } + function visitMethodDeclaration(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return undefined; + } + var updated = ts.updateMethod(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context)); + if (updated !== node) { + ts.setCommentRange(updated, node); + ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node)); + } + return updated; + } + function shouldEmitAccessorDeclaration(node) { + return !(ts.nodeIsMissing(node.body) && ts.hasModifier(node, 128)); + } + function visitGetAccessor(node) { + if (!shouldEmitAccessorDeclaration(node)) { + return undefined; + } + var updated = ts.updateGetAccessor(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([])); + if (updated !== node) { + ts.setCommentRange(updated, node); + ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node)); + } + return updated; + } + function visitSetAccessor(node) { + if (!shouldEmitAccessorDeclaration(node)) { + return undefined; + } + var updated = ts.updateSetAccessor(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([])); + if (updated !== node) { + ts.setCommentRange(updated, node); + ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node)); + } + return updated; + } + function visitFunctionDeclaration(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return ts.createNotEmittedStatement(node); + } + var updated = ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([])); + if (isExportOfNamespace(node)) { + var statements = [updated]; + addExportMemberAssignment(statements, node); + return statements; + } + return updated; + } + function visitFunctionExpression(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return ts.createOmittedExpression(); + } + var updated = ts.updateFunctionExpression(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([])); + return updated; + } + function visitArrowFunction(node) { + var updated = ts.updateArrowFunction(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.visitFunctionBody(node.body, visitor, context)); + return updated; + } + function visitParameter(node) { + if (ts.parameterIsThisKeyword(node)) { + return undefined; + } + var updated = ts.updateParameter(node, undefined, undefined, node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + if (updated !== node) { + ts.setCommentRange(updated, node); + ts.setTextRange(updated, ts.moveRangePastModifiers(node)); + ts.setSourceMapRange(updated, ts.moveRangePastModifiers(node)); + ts.setEmitFlags(updated.name, 32); + } + return updated; + } + function visitVariableStatement(node) { + if (isExportOfNamespace(node)) { + var variables = ts.getInitializedVariables(node.declarationList); + if (variables.length === 0) { + return undefined; + } + return ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(ts.map(variables, transformInitializedVariable))), node); + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformInitializedVariable(node) { + var name = node.name; + if (ts.isBindingPattern(name)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0, false, createNamespaceExportExpression); + } + else { + return ts.setTextRange(ts.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node); + } + } + function visitVariableDeclaration(node) { + return ts.updateTypeScriptVariableDeclaration(node, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + } + function visitParenthesizedExpression(node) { + var innerExpression = ts.skipOuterExpressions(node.expression, ~2); + if (ts.isAssertionExpression(innerExpression)) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + if (ts.length(ts.getLeadingCommentRangesOfNode(expression, currentSourceFile))) { + return ts.updateParen(node, expression); + } + return ts.createPartiallyEmittedExpression(expression, node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitAssertionExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + return ts.createPartiallyEmittedExpression(expression, node); + } + function visitNonNullExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression); + return ts.createPartiallyEmittedExpression(expression, node); + } + function visitCallExpression(node) { + return ts.updateCall(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitNewExpression(node) { + return ts.updateNew(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitTaggedTemplateExpression(node) { + return ts.updateTaggedTemplate(node, ts.visitNode(node.tag, visitor, ts.isExpression), undefined, ts.visitNode(node.template, visitor, ts.isExpression)); + } + function shouldEmitEnumDeclaration(node) { + return !ts.isEnumConst(node) + || compilerOptions.preserveConstEnums + || compilerOptions.isolatedModules; + } + function visitEnumDeclaration(node) { + if (!shouldEmitEnumDeclaration(node)) { + return ts.createNotEmittedStatement(node); + } + var statements = []; + var emitFlags = 2; + var varAdded = addVarForEnumOrModuleDeclaration(statements, node); + if (varAdded) { + if (moduleKind !== ts.ModuleKind.System || currentLexicalScope !== currentSourceFile) { + emitFlags |= 512; + } + } + var parameterName = getNamespaceParameterName(node); + var containerName = getNamespaceContainerName(node); + var exportName = ts.hasModifier(node, 1) + ? ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) + : ts.getLocalName(node, false, true); + var moduleArg = ts.createLogicalOr(exportName, ts.createAssignment(exportName, ts.createObjectLiteral())); + if (hasNamespaceQualifiedExportName(node)) { + var localName = ts.getLocalName(node, false, true); + moduleArg = ts.createAssignment(localName, moduleArg); + } + var enumStatement = ts.createExpressionStatement(ts.createCall(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, transformEnumBody(node, containerName)), undefined, [moduleArg])); + ts.setOriginalNode(enumStatement, node); + if (varAdded) { + ts.setSyntheticLeadingComments(enumStatement, undefined); + ts.setSyntheticTrailingComments(enumStatement, undefined); + } + ts.setTextRange(enumStatement, node); + ts.addEmitFlags(enumStatement, emitFlags); + statements.push(enumStatement); + statements.push(ts.createEndOfDeclarationMarker(node)); + return statements; + } + function transformEnumBody(node, localName) { + var savedCurrentNamespaceLocalName = currentNamespaceContainerName; + currentNamespaceContainerName = localName; + var statements = []; + startLexicalEnvironment(); + var members = ts.map(node.members, transformEnumMember); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + ts.addRange(statements, members); + currentNamespaceContainerName = savedCurrentNamespaceLocalName; + return ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), node.members), true); + } + function transformEnumMember(member) { + var name = getExpressionForPropertyName(member, false); + var valueExpression = transformEnumMemberDeclarationValue(member); + var innerAssignment = ts.createAssignment(ts.createElementAccess(currentNamespaceContainerName, name), valueExpression); + var outerAssignment = valueExpression.kind === 10 ? + innerAssignment : + ts.createAssignment(ts.createElementAccess(currentNamespaceContainerName, innerAssignment), name); + return ts.setTextRange(ts.createExpressionStatement(ts.setTextRange(outerAssignment, member)), member); + } + function transformEnumMemberDeclarationValue(member) { + var value = resolver.getConstantValue(member); + if (value !== undefined) { + return ts.createLiteral(value); + } + else { + enableSubstitutionForNonQualifiedEnumMembers(); + if (member.initializer) { + return ts.visitNode(member.initializer, visitor, ts.isExpression); + } + else { + return ts.createVoidZero(); + } + } + } + function shouldEmitModuleDeclaration(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isModuleDeclaration); + if (!node) { + return true; + } + return ts.isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules); + } + function hasNamespaceQualifiedExportName(node) { + return isExportOfNamespace(node) + || (isExternalModuleExport(node) + && moduleKind !== ts.ModuleKind.ES2015 + && moduleKind !== ts.ModuleKind.ES2020 + && moduleKind !== ts.ModuleKind.ESNext + && moduleKind !== ts.ModuleKind.System); + } + function recordEmittedDeclarationInScope(node) { + if (!currentScopeFirstDeclarationsOfName) { + currentScopeFirstDeclarationsOfName = ts.createUnderscoreEscapedMap(); + } + var name = declaredNameInScope(node); + if (!currentScopeFirstDeclarationsOfName.has(name)) { + currentScopeFirstDeclarationsOfName.set(name, node); + } + } + function isFirstEmittedDeclarationInScope(node) { + if (currentScopeFirstDeclarationsOfName) { + var name = declaredNameInScope(node); + return currentScopeFirstDeclarationsOfName.get(name) === node; + } + return true; + } + function declaredNameInScope(node) { + ts.Debug.assertNode(node.name, ts.isIdentifier); + return node.name.escapedText; + } + function addVarForEnumOrModuleDeclaration(statements, node) { + var statement = ts.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.getLocalName(node, false, true)) + ], currentLexicalScope.kind === 290 ? 0 : 1)); + ts.setOriginalNode(statement, node); + recordEmittedDeclarationInScope(node); + if (isFirstEmittedDeclarationInScope(node)) { + if (node.kind === 248) { + ts.setSourceMapRange(statement.declarationList, node); + } + else { + ts.setSourceMapRange(statement, node); + } + ts.setCommentRange(statement, node); + ts.addEmitFlags(statement, 1024 | 4194304); + statements.push(statement); + return true; + } + else { + var mergeMarker = ts.createMergeDeclarationMarker(statement); + ts.setEmitFlags(mergeMarker, 1536 | 4194304); + statements.push(mergeMarker); + return false; + } + } + function visitModuleDeclaration(node) { + if (!shouldEmitModuleDeclaration(node)) { + return ts.createNotEmittedStatement(node); + } + ts.Debug.assertNode(node.name, ts.isIdentifier, "A TypeScript namespace should have an Identifier name."); + enableSubstitutionForNamespaceExports(); + var statements = []; + var emitFlags = 2; + var varAdded = addVarForEnumOrModuleDeclaration(statements, node); + if (varAdded) { + if (moduleKind !== ts.ModuleKind.System || currentLexicalScope !== currentSourceFile) { + emitFlags |= 512; + } + } + var parameterName = getNamespaceParameterName(node); + var containerName = getNamespaceContainerName(node); + var exportName = ts.hasModifier(node, 1) + ? ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) + : ts.getLocalName(node, false, true); + var moduleArg = ts.createLogicalOr(exportName, ts.createAssignment(exportName, ts.createObjectLiteral())); + if (hasNamespaceQualifiedExportName(node)) { + var localName = ts.getLocalName(node, false, true); + moduleArg = ts.createAssignment(localName, moduleArg); + } + var moduleStatement = ts.createExpressionStatement(ts.createCall(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, transformModuleBody(node, containerName)), undefined, [moduleArg])); + ts.setOriginalNode(moduleStatement, node); + if (varAdded) { + ts.setSyntheticLeadingComments(moduleStatement, undefined); + ts.setSyntheticTrailingComments(moduleStatement, undefined); + } + ts.setTextRange(moduleStatement, node); + ts.addEmitFlags(moduleStatement, emitFlags); + statements.push(moduleStatement); + statements.push(ts.createEndOfDeclarationMarker(node)); + return statements; + } + function transformModuleBody(node, namespaceLocalName) { + var savedCurrentNamespaceContainerName = currentNamespaceContainerName; + var savedCurrentNamespace = currentNamespace; + var savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName; + currentNamespaceContainerName = namespaceLocalName; + currentNamespace = node; + currentScopeFirstDeclarationsOfName = undefined; + var statements = []; + startLexicalEnvironment(); + var statementsLocation; + var blockLocation; + var body = node.body; + if (body.kind === 250) { + saveStateAndInvoke(body, function (body) { return ts.addRange(statements, ts.visitNodes(body.statements, namespaceElementVisitor, ts.isStatement)); }); + statementsLocation = body.statements; + blockLocation = body; + } + else { + var result = visitModuleDeclaration(body); + if (result) { + if (ts.isArray(result)) { + ts.addRange(statements, result); + } + else { + statements.push(result); + } + } + var moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body; + statementsLocation = ts.moveRangePos(moduleBlock.statements, -1); + } + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + currentNamespaceContainerName = savedCurrentNamespaceContainerName; + currentNamespace = savedCurrentNamespace; + currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName; + var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true); + ts.setTextRange(block, blockLocation); + if (body.kind !== 250) { + ts.setEmitFlags(block, ts.getEmitFlags(block) | 1536); + } + return block; + } + function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { + if (moduleDeclaration.body.kind === 249) { + var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); + return recursiveInnerModule || moduleDeclaration.body; + } + } + function visitImportDeclaration(node) { + if (!node.importClause) { + return node; + } + if (node.importClause.isTypeOnly) { + return undefined; + } + var importClause = ts.visitNode(node.importClause, visitImportClause, ts.isImportClause); + return importClause || + compilerOptions.importsNotUsedAsValues === 1 || + compilerOptions.importsNotUsedAsValues === 2 + ? ts.updateImportDeclaration(node, undefined, undefined, importClause, node.moduleSpecifier) + : undefined; + } + function visitImportClause(node) { + if (node.isTypeOnly) { + return undefined; + } + var name = resolver.isReferencedAliasDeclaration(node) ? node.name : undefined; + var namedBindings = ts.visitNode(node.namedBindings, visitNamedImportBindings, ts.isNamedImportBindings); + return (name || namedBindings) ? ts.updateImportClause(node, name, namedBindings, false) : undefined; + } + function visitNamedImportBindings(node) { + if (node.kind === 256) { + return resolver.isReferencedAliasDeclaration(node) ? node : undefined; + } + else { + var elements = ts.visitNodes(node.elements, visitImportSpecifier, ts.isImportSpecifier); + return ts.some(elements) ? ts.updateNamedImports(node, elements) : undefined; + } + } + function visitImportSpecifier(node) { + return resolver.isReferencedAliasDeclaration(node) ? node : undefined; + } + function visitExportAssignment(node) { + return resolver.isValueAliasDeclaration(node) + ? ts.visitEachChild(node, visitor, context) + : undefined; + } + function visitExportDeclaration(node) { + if (node.isTypeOnly) { + return undefined; + } + if (!node.exportClause) { + return compilerOptions.isolatedModules || resolver.moduleExportsSomeValue(node.moduleSpecifier) ? node : undefined; + } + if (!resolver.isValueAliasDeclaration(node)) { + return undefined; + } + var exportClause = ts.visitNode(node.exportClause, visitNamedExportBindings, ts.isNamedImportBindings); + return exportClause + ? ts.updateExportDeclaration(node, undefined, undefined, exportClause, node.moduleSpecifier, node.isTypeOnly) + : undefined; + } + function visitNamedExports(node) { + var elements = ts.visitNodes(node.elements, visitExportSpecifier, ts.isExportSpecifier); + return ts.some(elements) ? ts.updateNamedExports(node, elements) : undefined; + } + function visitNamespaceExports(node) { + return ts.updateNamespaceExport(node, ts.visitNode(node.name, visitor, ts.isIdentifier)); + } + function visitNamedExportBindings(node) { + return ts.isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node); + } + function visitExportSpecifier(node) { + return resolver.isValueAliasDeclaration(node) ? node : undefined; + } + function shouldEmitImportEqualsDeclaration(node) { + return resolver.isReferencedAliasDeclaration(node) + || (!ts.isExternalModule(currentSourceFile) + && resolver.isTopLevelValueImportEqualsWithEntityName(node)); + } + function visitImportEqualsDeclaration(node) { + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + var isReferenced = resolver.isReferencedAliasDeclaration(node); + if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1) { + return ts.setOriginalNode(ts.setTextRange(ts.createImportDeclaration(undefined, undefined, undefined, node.moduleReference.expression), node), node); + } + return isReferenced ? ts.visitEachChild(node, visitor, context) : undefined; + } + if (!shouldEmitImportEqualsDeclaration(node)) { + return undefined; + } + var moduleReference = ts.createExpressionFromEntityName(node.moduleReference); + ts.setEmitFlags(moduleReference, 1536 | 2048); + if (isNamedExternalModuleExport(node) || !isExportOfNamespace(node)) { + return ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.createVariableDeclarationList([ + ts.setOriginalNode(ts.createVariableDeclaration(node.name, undefined, moduleReference), node) + ])), node), node); + } + else { + return ts.setOriginalNode(createNamespaceExport(node.name, moduleReference, node), node); + } + } + function isExportOfNamespace(node) { + return currentNamespace !== undefined && ts.hasModifier(node, 1); + } + function isExternalModuleExport(node) { + return currentNamespace === undefined && ts.hasModifier(node, 1); + } + function isNamedExternalModuleExport(node) { + return isExternalModuleExport(node) + && !ts.hasModifier(node, 512); + } + function isDefaultExternalModuleExport(node) { + return isExternalModuleExport(node) + && ts.hasModifier(node, 512); + } + function expressionToStatement(expression) { + return ts.createExpressionStatement(expression); + } + function addExportMemberAssignment(statements, node) { + var expression = ts.createAssignment(ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true), ts.getLocalName(node)); + ts.setSourceMapRange(expression, ts.createRange(node.name ? node.name.pos : node.pos, node.end)); + var statement = ts.createExpressionStatement(expression); + ts.setSourceMapRange(statement, ts.createRange(-1, node.end)); + statements.push(statement); + } + function createNamespaceExport(exportName, exportValue, location) { + return ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(ts.getNamespaceMemberName(currentNamespaceContainerName, exportName, false, true), exportValue)), location); + } + function createNamespaceExportExpression(exportName, exportValue, location) { + return ts.setTextRange(ts.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location); + } + function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name) { + return ts.getNamespaceMemberName(currentNamespaceContainerName, name, false, true); + } + function getNamespaceParameterName(node) { + var name = ts.getGeneratedNameForNode(node); + ts.setSourceMapRange(name, node.name); + return name; + } + function getNamespaceContainerName(node) { + return ts.getGeneratedNameForNode(node); + } + function getClassAliasIfNeeded(node) { + if (resolver.getNodeCheckFlags(node) & 16777216) { + enableSubstitutionForClassAliases(); + var classAlias = ts.createUniqueName(node.name && !ts.isGeneratedIdentifier(node.name) ? ts.idText(node.name) : "default"); + classAliases[ts.getOriginalNodeId(node)] = classAlias; + hoistVariableDeclaration(classAlias); + return classAlias; + } + } + function getClassPrototype(node) { + return ts.createPropertyAccess(ts.getDeclarationName(node), "prototype"); + } + function getClassMemberPrefix(node, member) { + return ts.hasModifier(member, 32) + ? ts.getDeclarationName(node) + : getClassPrototype(node); + } + function enableSubstitutionForNonQualifiedEnumMembers() { + if ((enabledSubstitutions & 8) === 0) { + enabledSubstitutions |= 8; + context.enableSubstitution(75); + } + } + function enableSubstitutionForClassAliases() { + if ((enabledSubstitutions & 1) === 0) { + enabledSubstitutions |= 1; + context.enableSubstitution(75); + classAliases = []; + } + } + function enableSubstitutionForNamespaceExports() { + if ((enabledSubstitutions & 2) === 0) { + enabledSubstitutions |= 2; + context.enableSubstitution(75); + context.enableSubstitution(282); + context.enableEmitNotification(249); + } + } + function isTransformedModuleDeclaration(node) { + return ts.getOriginalNode(node).kind === 249; + } + function isTransformedEnumDeclaration(node) { + return ts.getOriginalNode(node).kind === 248; + } + function onEmitNode(hint, node, emitCallback) { + var savedApplicableSubstitutions = applicableSubstitutions; + var savedCurrentSourceFile = currentSourceFile; + if (ts.isSourceFile(node)) { + currentSourceFile = node; + } + if (enabledSubstitutions & 2 && isTransformedModuleDeclaration(node)) { + applicableSubstitutions |= 2; + } + if (enabledSubstitutions & 8 && isTransformedEnumDeclaration(node)) { + applicableSubstitutions |= 8; + } + previousOnEmitNode(hint, node, emitCallback); + applicableSubstitutions = savedApplicableSubstitutions; + currentSourceFile = savedCurrentSourceFile; + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1) { + return substituteExpression(node); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return substituteShorthandPropertyAssignment(node); + } + return node; + } + function substituteShorthandPropertyAssignment(node) { + if (enabledSubstitutions & 2) { + var name = node.name; + var exportedName = trySubstituteNamespaceExportedName(name); + if (exportedName) { + if (node.objectAssignmentInitializer) { + var initializer = ts.createAssignment(exportedName, node.objectAssignmentInitializer); + return ts.setTextRange(ts.createPropertyAssignment(name, initializer), node); + } + return ts.setTextRange(ts.createPropertyAssignment(name, exportedName), node); + } + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 75: + return substituteExpressionIdentifier(node); + case 194: + return substitutePropertyAccessExpression(node); + case 195: + return substituteElementAccessExpression(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + return trySubstituteClassAlias(node) + || trySubstituteNamespaceExportedName(node) + || node; + } + function trySubstituteClassAlias(node) { + if (enabledSubstitutions & 1) { + if (resolver.getNodeCheckFlags(node) & 33554432) { + var declaration = resolver.getReferencedValueDeclaration(node); + if (declaration) { + var classAlias = classAliases[declaration.id]; + if (classAlias) { + var clone_1 = ts.getSynthesizedClone(classAlias); + ts.setSourceMapRange(clone_1, node); + ts.setCommentRange(clone_1, node); + return clone_1; + } + } + } + } + return undefined; + } + function trySubstituteNamespaceExportedName(node) { + if (enabledSubstitutions & applicableSubstitutions && !ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) { + var container = resolver.getReferencedExportContainer(node, false); + if (container && container.kind !== 290) { + var substitute = (applicableSubstitutions & 2 && container.kind === 249) || + (applicableSubstitutions & 8 && container.kind === 248); + if (substitute) { + return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(container), node), node); + } + } + } + return undefined; + } + function substitutePropertyAccessExpression(node) { + return substituteConstantValue(node); + } + function substituteElementAccessExpression(node) { + return substituteConstantValue(node); + } + function substituteConstantValue(node) { + var constantValue = tryGetConstEnumValue(node); + if (constantValue !== undefined) { + ts.setConstantValue(node, constantValue); + var substitute = ts.createLiteral(constantValue); + if (!compilerOptions.removeComments) { + var originalNode = ts.getOriginalNode(node, ts.isAccessExpression); + var propertyName = ts.isPropertyAccessExpression(originalNode) + ? ts.declarationNameToString(originalNode.name) + : ts.getTextOfNode(originalNode.argumentExpression); + ts.addSyntheticTrailingComment(substitute, 3, " " + propertyName + " "); + } + return substitute; + } + return node; + } + function tryGetConstEnumValue(node) { + if (compilerOptions.isolatedModules) { + return undefined; + } + return ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) ? resolver.getConstantValue(node) : undefined; + } + } + ts.transformTypeScript = transformTypeScript; + function createDecorateHelper(context, decoratorExpressions, target, memberName, descriptor, location) { + var argumentsArray = []; + argumentsArray.push(ts.createArrayLiteral(decoratorExpressions, true)); + argumentsArray.push(target); + if (memberName) { + argumentsArray.push(memberName); + if (descriptor) { + argumentsArray.push(descriptor); + } + } + context.requestEmitHelper(ts.decorateHelper); + return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__decorate"), undefined, argumentsArray), location); + } + ts.decorateHelper = { + name: "typescript:decorate", + importName: "__decorate", + scoped: false, + priority: 2, + text: "\n var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n };" + }; + function createMetadataHelper(context, metadataKey, metadataValue) { + context.requestEmitHelper(ts.metadataHelper); + return ts.createCall(ts.getUnscopedHelperName("__metadata"), undefined, [ + ts.createLiteral(metadataKey), + metadataValue + ]); + } + ts.metadataHelper = { + name: "typescript:metadata", + importName: "__metadata", + scoped: false, + priority: 3, + text: "\n var __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n };" + }; + function createParamHelper(context, expression, parameterOffset, location) { + context.requestEmitHelper(ts.paramHelper); + return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__param"), undefined, [ + ts.createLiteral(parameterOffset), + expression + ]), location); + } + ts.paramHelper = { + name: "typescript:param", + importName: "__param", + scoped: false, + priority: 4, + text: "\n var __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n };" + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformClassFields(context) { + var hoistVariableDeclaration = context.hoistVariableDeclaration, endLexicalEnvironment = context.endLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var shouldTransformPrivateFields = languageVersion < 99; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var enabledSubstitutions; + var classAliases; + var pendingExpressions; + var pendingStatements; + var privateIdentifierEnvironmentStack = []; + var currentPrivateIdentifierEnvironment; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + var options = context.getCompilerOptions(); + if (node.isDeclarationFile + || options.useDefineForClassFields && options.target === 99) { + return node; + } + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function visitor(node) { + if (!(node.transformFlags & 4194304)) + return node; + switch (node.kind) { + case 214: + case 245: + return visitClassLike(node); + case 159: + return visitPropertyDeclaration(node); + case 225: + return visitVariableStatement(node); + case 154: + return visitComputedPropertyName(node); + case 194: + return visitPropertyAccessExpression(node); + case 207: + return visitPrefixUnaryExpression(node); + case 208: + return visitPostfixUnaryExpression(node, false); + case 196: + return visitCallExpression(node); + case 209: + return visitBinaryExpression(node); + case 76: + return visitPrivateIdentifier(node); + case 226: + return visitExpressionStatement(node); + case 230: + return visitForStatement(node); + case 198: + return visitTaggedTemplateExpression(node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitorDestructuringTarget(node) { + switch (node.kind) { + case 193: + case 192: + return visitAssignmentPattern(node); + default: + return visitor(node); + } + } + function visitPrivateIdentifier(node) { + if (!shouldTransformPrivateFields) { + return node; + } + return ts.setOriginalNode(ts.createIdentifier(""), node); + } + function classElementVisitor(node) { + switch (node.kind) { + case 162: + return undefined; + case 163: + case 164: + case 161: + return ts.visitEachChild(node, classElementVisitor, context); + case 159: + return visitPropertyDeclaration(node); + case 154: + return visitComputedPropertyName(node); + case 222: + return node; + default: + return visitor(node); + } + } + function visitVariableStatement(node) { + var savedPendingStatements = pendingStatements; + pendingStatements = []; + var visitedNode = ts.visitEachChild(node, visitor, context); + var statement = ts.some(pendingStatements) ? __spreadArrays([visitedNode], pendingStatements) : + visitedNode; + pendingStatements = savedPendingStatements; + return statement; + } + function visitComputedPropertyName(name) { + var node = ts.visitEachChild(name, visitor, context); + if (ts.some(pendingExpressions)) { + var expressions = pendingExpressions; + expressions.push(name.expression); + pendingExpressions = []; + node = ts.updateComputedPropertyName(node, ts.inlineExpressions(expressions)); + } + return node; + } + function visitPropertyDeclaration(node) { + ts.Debug.assert(!ts.some(node.decorators)); + if (!shouldTransformPrivateFields && ts.isPrivateIdentifier(node.name)) { + return ts.updateProperty(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, undefined, undefined, undefined); + } + var expr = getPropertyNameExpressionIfNeeded(node.name, !!node.initializer || !!context.getCompilerOptions().useDefineForClassFields); + if (expr && !ts.isSimpleInlineableExpression(expr)) { + (pendingExpressions || (pendingExpressions = [])).push(expr); + } + return undefined; + } + function createPrivateIdentifierAccess(info, receiver) { + receiver = ts.visitNode(receiver, visitor, ts.isExpression); + switch (info.placement) { + case 0: + return createClassPrivateFieldGetHelper(context, ts.nodeIsSynthesized(receiver) ? receiver : ts.getSynthesizedClone(receiver), info.weakMapName); + default: return ts.Debug.fail("Unexpected private identifier placement"); + } + } + function visitPropertyAccessExpression(node) { + if (shouldTransformPrivateFields && ts.isPrivateIdentifier(node.name)) { + var privateIdentifierInfo = accessPrivateIdentifier(node.name); + if (privateIdentifierInfo) { + return ts.setOriginalNode(createPrivateIdentifierAccess(privateIdentifierInfo, node.expression), node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitPrefixUnaryExpression(node) { + if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.operand)) { + var operator = node.operator === 45 ? + 39 : node.operator === 46 ? + 40 : undefined; + var info = void 0; + if (operator && (info = accessPrivateIdentifier(node.operand.name))) { + var receiver = ts.visitNode(node.operand.expression, visitor, ts.isExpression); + var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression; + var existingValue = ts.createPrefix(39, createPrivateIdentifierAccess(info, readExpression)); + return ts.setOriginalNode(createPrivateIdentifierAssignment(info, initializeExpression || readExpression, ts.createBinary(existingValue, operator, ts.createLiteral(1)), 62), node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitPostfixUnaryExpression(node, valueIsDiscarded) { + if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.operand)) { + var operator = node.operator === 45 ? + 39 : node.operator === 46 ? + 40 : undefined; + var info = void 0; + if (operator && (info = accessPrivateIdentifier(node.operand.name))) { + var receiver = ts.visitNode(node.operand.expression, visitor, ts.isExpression); + var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression; + var existingValue = ts.createPrefix(39, createPrivateIdentifierAccess(info, readExpression)); + var returnValue = valueIsDiscarded ? undefined : ts.createTempVariable(hoistVariableDeclaration); + return ts.setOriginalNode(ts.inlineExpressions(ts.compact([ + createPrivateIdentifierAssignment(info, initializeExpression || readExpression, ts.createBinary(returnValue ? ts.createAssignment(returnValue, existingValue) : existingValue, operator, ts.createLiteral(1)), 62), + returnValue + ])), node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitForStatement(node) { + if (node.incrementor && ts.isPostfixUnaryExpression(node.incrementor)) { + return ts.updateFor(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), visitPostfixUnaryExpression(node.incrementor, true), ts.visitNode(node.statement, visitor, ts.isStatement)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitExpressionStatement(node) { + if (ts.isPostfixUnaryExpression(node.expression)) { + return ts.updateExpressionStatement(node, visitPostfixUnaryExpression(node.expression, true)); + } + return ts.visitEachChild(node, visitor, context); + } + function createCopiableReceiverExpr(receiver) { + var clone = ts.nodeIsSynthesized(receiver) ? receiver : ts.getSynthesizedClone(receiver); + if (ts.isSimpleInlineableExpression(receiver)) { + return { readExpression: clone, initializeExpression: undefined }; + } + var readExpression = ts.createTempVariable(hoistVariableDeclaration); + var initializeExpression = ts.createAssignment(readExpression, clone); + return { readExpression: readExpression, initializeExpression: initializeExpression }; + } + function visitCallExpression(node) { + if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.expression)) { + var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target; + return ts.updateCall(node, ts.createPropertyAccess(ts.visitNode(target, visitor), "call"), undefined, __spreadArrays([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression))); + } + return ts.visitEachChild(node, visitor, context); + } + function visitTaggedTemplateExpression(node) { + if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.tag)) { + var _a = ts.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target; + return ts.updateTaggedTemplate(node, ts.createCall(ts.createPropertyAccess(ts.visitNode(target, visitor), "bind"), undefined, [ts.visitNode(thisArg, visitor, ts.isExpression)]), ts.visitNode(node.template, visitor, ts.isTemplateLiteral)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitBinaryExpression(node) { + if (shouldTransformPrivateFields) { + if (ts.isDestructuringAssignment(node)) { + var savedPendingExpressions = pendingExpressions; + pendingExpressions = undefined; + node = ts.updateBinary(node, ts.visitNode(node.left, visitorDestructuringTarget), ts.visitNode(node.right, visitor), node.operatorToken); + var expr = ts.some(pendingExpressions) ? + ts.inlineExpressions(ts.compact(__spreadArrays(pendingExpressions, [node]))) : + node; + pendingExpressions = savedPendingExpressions; + return expr; + } + if (ts.isAssignmentExpression(node) && ts.isPrivateIdentifierPropertyAccessExpression(node.left)) { + var info = accessPrivateIdentifier(node.left.name); + if (info) { + return ts.setOriginalNode(createPrivateIdentifierAssignment(info, node.left.expression, node.right, node.operatorToken.kind), node); + } + } + } + return ts.visitEachChild(node, visitor, context); + } + function createPrivateIdentifierAssignment(info, receiver, right, operator) { + switch (info.placement) { + case 0: { + return createPrivateIdentifierInstanceFieldAssignment(info, receiver, right, operator); + } + default: return ts.Debug.fail("Unexpected private identifier placement"); + } + } + function createPrivateIdentifierInstanceFieldAssignment(info, receiver, right, operator) { + receiver = ts.visitNode(receiver, visitor, ts.isExpression); + right = ts.visitNode(right, visitor, ts.isExpression); + if (ts.isCompoundAssignment(operator)) { + var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression; + return createClassPrivateFieldSetHelper(context, initializeExpression || readExpression, info.weakMapName, ts.createBinary(createClassPrivateFieldGetHelper(context, readExpression, info.weakMapName), ts.getNonAssignmentOperatorForCompoundAssignment(operator), right)); + } + else { + return createClassPrivateFieldSetHelper(context, receiver, info.weakMapName, right); + } + } + function visitClassLike(node) { + var savedPendingExpressions = pendingExpressions; + pendingExpressions = undefined; + if (shouldTransformPrivateFields) { + startPrivateIdentifierEnvironment(); + } + var result = ts.isClassDeclaration(node) ? + visitClassDeclaration(node) : + visitClassExpression(node); + if (shouldTransformPrivateFields) { + endPrivateIdentifierEnvironment(); + } + pendingExpressions = savedPendingExpressions; + return result; + } + function doesClassElementNeedTransform(node) { + return ts.isPropertyDeclaration(node) || (shouldTransformPrivateFields && node.name && ts.isPrivateIdentifier(node.name)); + } + function visitClassDeclaration(node) { + if (!ts.forEach(node.members, doesClassElementNeedTransform)) { + return ts.visitEachChild(node, visitor, context); + } + var extendsClauseElement = ts.getEffectiveBaseTypeNode(node); + var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100); + var statements = [ + ts.updateClassDeclaration(node, undefined, node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass)) + ]; + if (ts.some(pendingExpressions)) { + statements.push(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions))); + } + var staticProperties = ts.getProperties(node, true, true); + if (ts.some(staticProperties)) { + addPropertyStatements(statements, staticProperties, ts.getInternalName(node)); + } + return statements; + } + function visitClassExpression(node) { + if (!ts.forEach(node.members, doesClassElementNeedTransform)) { + return ts.visitEachChild(node, visitor, context); + } + var isDecoratedClassDeclaration = ts.isClassDeclaration(ts.getOriginalNode(node)); + var staticProperties = ts.getProperties(node, true, true); + var extendsClauseElement = ts.getEffectiveBaseTypeNode(node); + var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100); + var classExpression = ts.updateClassExpression(node, node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass)); + if (ts.some(staticProperties) || ts.some(pendingExpressions)) { + if (isDecoratedClassDeclaration) { + ts.Debug.assertDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration."); + if (pendingStatements && pendingExpressions && ts.some(pendingExpressions)) { + pendingStatements.push(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions))); + } + if (pendingStatements && ts.some(staticProperties)) { + addPropertyStatements(pendingStatements, staticProperties, ts.getInternalName(node)); + } + return classExpression; + } + else { + var expressions = []; + var isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216; + var temp = ts.createTempVariable(hoistVariableDeclaration, !!isClassWithConstructorReference); + if (isClassWithConstructorReference) { + enableSubstitutionForClassAliases(); + var alias = ts.getSynthesizedClone(temp); + alias.autoGenerateFlags &= ~8; + classAliases[ts.getOriginalNodeId(node)] = alias; + } + ts.setEmitFlags(classExpression, 65536 | ts.getEmitFlags(classExpression)); + expressions.push(ts.startOnNewLine(ts.createAssignment(temp, classExpression))); + ts.addRange(expressions, ts.map(pendingExpressions, ts.startOnNewLine)); + ts.addRange(expressions, generateInitializedPropertyExpressions(staticProperties, temp)); + expressions.push(ts.startOnNewLine(temp)); + return ts.inlineExpressions(expressions); + } + } + return classExpression; + } + function transformClassMembers(node, isDerivedClass) { + if (shouldTransformPrivateFields) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.isPrivateIdentifierPropertyDeclaration(member)) { + addPrivateIdentifierToEnvironment(member.name); + } + } + } + var members = []; + var constructor = transformConstructor(node, isDerivedClass); + if (constructor) { + members.push(constructor); + } + ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement)); + return ts.setTextRange(ts.createNodeArray(members), node.members); + } + function isPropertyDeclarationThatRequiresConstructorStatement(member) { + if (!ts.isPropertyDeclaration(member) || ts.hasStaticModifier(member)) { + return false; + } + if (context.getCompilerOptions().useDefineForClassFields) { + return languageVersion < 99; + } + return ts.isInitializedProperty(member) || shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyDeclaration(member); + } + function transformConstructor(node, isDerivedClass) { + var constructor = ts.visitNode(ts.getFirstConstructorWithBody(node), visitor, ts.isConstructorDeclaration); + var properties = node.members.filter(isPropertyDeclarationThatRequiresConstructorStatement); + if (!ts.some(properties)) { + return constructor; + } + var parameters = ts.visitParameterList(constructor ? constructor.parameters : undefined, visitor, context); + var body = transformConstructorBody(node, constructor, isDerivedClass); + if (!body) { + return undefined; + } + return ts.startOnNewLine(ts.setOriginalNode(ts.setTextRange(ts.createConstructor(undefined, undefined, parameters, body), constructor || node), constructor)); + } + function transformConstructorBody(node, constructor, isDerivedClass) { + var useDefineForClassFields = context.getCompilerOptions().useDefineForClassFields; + var properties = ts.getProperties(node, false, false); + if (!useDefineForClassFields) { + properties = ts.filter(properties, function (property) { return !!property.initializer || ts.isPrivateIdentifier(property.name); }); + } + if (!constructor && !ts.some(properties)) { + return ts.visitFunctionBody(undefined, visitor, context); + } + resumeLexicalEnvironment(); + var indexOfFirstStatement = 0; + var statements = []; + if (!constructor && isDerivedClass) { + statements.push(ts.createExpressionStatement(ts.createCall(ts.createSuper(), undefined, [ts.createSpread(ts.createIdentifier("arguments"))]))); + } + if (constructor) { + indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor); + } + if (constructor === null || constructor === void 0 ? void 0 : constructor.body) { + var afterParameterProperties = ts.findIndex(constructor.body.statements, function (s) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(s), constructor); }, indexOfFirstStatement); + if (afterParameterProperties === -1) { + afterParameterProperties = constructor.body.statements.length; + } + if (afterParameterProperties > indexOfFirstStatement) { + if (!useDefineForClassFields) { + ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement, afterParameterProperties - indexOfFirstStatement)); + } + indexOfFirstStatement = afterParameterProperties; + } + } + addPropertyStatements(statements, properties, ts.createThis()); + if (constructor) { + ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement)); + } + statements = ts.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + return ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), constructor ? constructor.body.statements : node.members), true), constructor ? constructor.body : undefined); + } + function addPropertyStatements(statements, properties, receiver) { + for (var _i = 0, properties_6 = properties; _i < properties_6.length; _i++) { + var property = properties_6[_i]; + var expression = transformProperty(property, receiver); + if (!expression) { + continue; + } + var statement = ts.createExpressionStatement(expression); + ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property)); + ts.setCommentRange(statement, property); + ts.setOriginalNode(statement, property); + statements.push(statement); + } + } + function generateInitializedPropertyExpressions(properties, receiver) { + var expressions = []; + for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) { + var property = properties_7[_i]; + var expression = transformProperty(property, receiver); + if (!expression) { + continue; + } + ts.startOnNewLine(expression); + ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property)); + ts.setCommentRange(expression, property); + ts.setOriginalNode(expression, property); + expressions.push(expression); + } + return expressions; + } + function transformProperty(property, receiver) { + var emitAssignment = !context.getCompilerOptions().useDefineForClassFields; + var propertyName = ts.isComputedPropertyName(property.name) && !ts.isSimpleInlineableExpression(property.name.expression) + ? ts.updateComputedPropertyName(property.name, ts.getGeneratedNameForNode(property.name)) + : property.name; + if (shouldTransformPrivateFields && ts.isPrivateIdentifier(propertyName)) { + var privateIdentifierInfo = accessPrivateIdentifier(propertyName); + if (privateIdentifierInfo) { + switch (privateIdentifierInfo.placement) { + case 0: { + return createPrivateInstanceFieldInitializer(receiver, ts.visitNode(property.initializer, visitor, ts.isExpression), privateIdentifierInfo.weakMapName); + } + } + } + else { + ts.Debug.fail("Undeclared private name for property declaration."); + } + } + if (ts.isPrivateIdentifier(propertyName) && !property.initializer) { + return undefined; + } + if (ts.isPrivateIdentifier(propertyName) && !property.initializer) { + return undefined; + } + var propertyOriginalNode = ts.getOriginalNode(property); + var initializer = property.initializer || emitAssignment ? ts.visitNode(property.initializer, visitor, ts.isExpression) + : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName + : ts.createVoidZero(); + if (emitAssignment || ts.isPrivateIdentifier(propertyName)) { + var memberAccess = ts.createMemberAccessForPropertyName(receiver, propertyName, propertyName); + return ts.createAssignment(memberAccess, initializer); + } + else { + var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression + : ts.isIdentifier(propertyName) ? ts.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText)) + : propertyName; + var descriptor = ts.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true }); + return ts.createObjectDefinePropertyCall(receiver, name, descriptor); + } + } + function enableSubstitutionForClassAliases() { + if ((enabledSubstitutions & 1) === 0) { + enabledSubstitutions |= 1; + context.enableSubstitution(75); + classAliases = []; + } + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 75: + return substituteExpressionIdentifier(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + return trySubstituteClassAlias(node) || node; + } + function trySubstituteClassAlias(node) { + if (enabledSubstitutions & 1) { + if (resolver.getNodeCheckFlags(node) & 33554432) { + var declaration = resolver.getReferencedValueDeclaration(node); + if (declaration) { + var classAlias = classAliases[declaration.id]; + if (classAlias) { + var clone_2 = ts.getSynthesizedClone(classAlias); + ts.setSourceMapRange(clone_2, node); + ts.setCommentRange(clone_2, node); + return clone_2; + } + } + } + } + return undefined; + } + function getPropertyNameExpressionIfNeeded(name, shouldHoist) { + if (ts.isComputedPropertyName(name)) { + var expression = ts.visitNode(name.expression, visitor, ts.isExpression); + var innerExpression = ts.skipPartiallyEmittedExpressions(expression); + var inlinable = ts.isSimpleInlineableExpression(innerExpression); + var alreadyTransformed = ts.isAssignmentExpression(innerExpression) && ts.isGeneratedIdentifier(innerExpression.left); + if (!alreadyTransformed && !inlinable && shouldHoist) { + var generatedName = ts.getGeneratedNameForNode(name); + hoistVariableDeclaration(generatedName); + return ts.createAssignment(generatedName, expression); + } + return (inlinable || ts.isIdentifier(innerExpression)) ? undefined : expression; + } + } + function startPrivateIdentifierEnvironment() { + privateIdentifierEnvironmentStack.push(currentPrivateIdentifierEnvironment); + currentPrivateIdentifierEnvironment = undefined; + } + function endPrivateIdentifierEnvironment() { + currentPrivateIdentifierEnvironment = privateIdentifierEnvironmentStack.pop(); + } + function addPrivateIdentifierToEnvironment(name) { + var text = ts.getTextOfPropertyName(name); + var weakMapName = ts.createOptimisticUniqueName("_" + text.substring(1)); + weakMapName.autoGenerateFlags |= 8; + hoistVariableDeclaration(weakMapName); + (currentPrivateIdentifierEnvironment || (currentPrivateIdentifierEnvironment = ts.createUnderscoreEscapedMap())) + .set(name.escapedText, { placement: 0, weakMapName: weakMapName }); + (pendingExpressions || (pendingExpressions = [])).push(ts.createAssignment(weakMapName, ts.createNew(ts.createIdentifier("WeakMap"), undefined, []))); + } + function accessPrivateIdentifier(name) { + if (currentPrivateIdentifierEnvironment) { + var info = currentPrivateIdentifierEnvironment.get(name.escapedText); + if (info) { + return info; + } + } + for (var i = privateIdentifierEnvironmentStack.length - 1; i >= 0; --i) { + var env = privateIdentifierEnvironmentStack[i]; + if (!env) { + continue; + } + var info = env.get(name.escapedText); + if (info) { + return info; + } + } + return undefined; + } + function wrapPrivateIdentifierForDestructuringTarget(node) { + var parameter = ts.getGeneratedNameForNode(node); + var info = accessPrivateIdentifier(node.name); + if (!info) { + return ts.visitEachChild(node, visitor, context); + } + var receiver = node.expression; + if (ts.isThisProperty(node) || ts.isSuperProperty(node) || !ts.isSimpleCopiableExpression(node.expression)) { + receiver = ts.createTempVariable(hoistVariableDeclaration); + receiver.autoGenerateFlags |= 8; + (pendingExpressions || (pendingExpressions = [])).push(ts.createBinary(receiver, 62, node.expression)); + } + return ts.createPropertyAccess(ts.createParen(ts.createObjectLiteral([ + ts.createSetAccessor(undefined, undefined, "value", [ts.createParameter(undefined, undefined, undefined, parameter, undefined, undefined, undefined)], ts.createBlock([ts.createExpressionStatement(createPrivateIdentifierAssignment(info, receiver, parameter, 62))])) + ])), "value"); + } + function visitArrayAssignmentTarget(node) { + var target = ts.getTargetOfBindingOrAssignmentElement(node); + if (target && ts.isPrivateIdentifierPropertyAccessExpression(target)) { + var wrapped = wrapPrivateIdentifierForDestructuringTarget(target); + if (ts.isAssignmentExpression(node)) { + return ts.updateBinary(node, wrapped, ts.visitNode(node.right, visitor, ts.isExpression), node.operatorToken); + } + else if (ts.isSpreadElement(node)) { + return ts.updateSpread(node, wrapped); + } + else { + return wrapped; + } + } + return ts.visitNode(node, visitorDestructuringTarget); + } + function visitObjectAssignmentTarget(node) { + if (ts.isPropertyAssignment(node)) { + var target = ts.getTargetOfBindingOrAssignmentElement(node); + if (target && ts.isPrivateIdentifierPropertyAccessExpression(target)) { + var initializer = ts.getInitializerOfBindingOrAssignmentElement(node); + var wrapped = wrapPrivateIdentifierForDestructuringTarget(target); + return ts.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), initializer ? ts.createAssignment(wrapped, ts.visitNode(initializer, visitor)) : wrapped); + } + return ts.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), ts.visitNode(node.initializer, visitorDestructuringTarget)); + } + return ts.visitNode(node, visitor); + } + function visitAssignmentPattern(node) { + if (ts.isArrayLiteralExpression(node)) { + return ts.updateArrayLiteral(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression)); + } + else { + return ts.updateObjectLiteral(node, ts.visitNodes(node.properties, visitObjectAssignmentTarget, ts.isObjectLiteralElementLike)); + } + } + } + ts.transformClassFields = transformClassFields; + function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) { + return ts.createCall(ts.createPropertyAccess(weakMapName, "set"), undefined, [receiver, initializer || ts.createVoidZero()]); + } + ts.classPrivateFieldGetHelper = { + name: "typescript:classPrivateFieldGet", + scoped: false, + text: "\n var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to get private field on non-instance\");\n }\n return privateMap.get(receiver);\n };" + }; + function createClassPrivateFieldGetHelper(context, receiver, privateField) { + context.requestEmitHelper(ts.classPrivateFieldGetHelper); + return ts.createCall(ts.getUnscopedHelperName("__classPrivateFieldGet"), undefined, [receiver, privateField]); + } + ts.classPrivateFieldSetHelper = { + name: "typescript:classPrivateFieldSet", + scoped: false, + text: "\n var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to set private field on non-instance\");\n }\n privateMap.set(receiver, value);\n return value;\n };" + }; + function createClassPrivateFieldSetHelper(context, receiver, privateField, value) { + context.requestEmitHelper(ts.classPrivateFieldSetHelper); + return ts.createCall(ts.getUnscopedHelperName("__classPrivateFieldSet"), undefined, [receiver, privateField, value]); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2017(context) { + var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var enabledSubstitutions; + var enclosingSuperContainerFlags = 0; + var enclosingFunctionParameterNames; + var capturedSuperProperties; + var hasSuperElementAccess; + var substitutedSuperAccessors = []; + var contextFlags = 0; + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + setContextFlag(1, false); + setContextFlag(2, !ts.isEffectiveStrictModeSourceFile(node, compilerOptions)); + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function setContextFlag(flag, val) { + contextFlags = val ? contextFlags | flag : contextFlags & ~flag; + } + function inContext(flags) { + return (contextFlags & flags) !== 0; + } + function inTopLevelContext() { + return !inContext(1); + } + function inHasLexicalThisContext() { + return inContext(2); + } + function doWithContext(flags, cb, value) { + var contextFlagsToSet = flags & ~contextFlags; + if (contextFlagsToSet) { + setContextFlag(contextFlagsToSet, true); + var result = cb(value); + setContextFlag(contextFlagsToSet, false); + return result; + } + return cb(value); + } + function visitDefault(node) { + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 64) === 0) { + return node; + } + switch (node.kind) { + case 126: + return undefined; + case 206: + return visitAwaitExpression(node); + case 161: + return doWithContext(1 | 2, visitMethodDeclaration, node); + case 244: + return doWithContext(1 | 2, visitFunctionDeclaration, node); + case 201: + return doWithContext(1 | 2, visitFunctionExpression, node); + case 202: + return doWithContext(1, visitArrowFunction, node); + case 194: + if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 102) { + capturedSuperProperties.set(node.name.escapedText, true); + } + return ts.visitEachChild(node, visitor, context); + case 195: + if (capturedSuperProperties && node.expression.kind === 102) { + hasSuperElementAccess = true; + } + return ts.visitEachChild(node, visitor, context); + case 163: + case 164: + case 162: + case 245: + case 214: + return doWithContext(1 | 2, visitDefault, node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function asyncBodyVisitor(node) { + if (ts.isNodeWithPossibleHoistedDeclaration(node)) { + switch (node.kind) { + case 225: + return visitVariableStatementInAsyncBody(node); + case 230: + return visitForStatementInAsyncBody(node); + case 231: + return visitForInStatementInAsyncBody(node); + case 232: + return visitForOfStatementInAsyncBody(node); + case 280: + return visitCatchClauseInAsyncBody(node); + case 223: + case 237: + case 251: + case 277: + case 278: + case 240: + case 228: + case 229: + case 227: + case 236: + case 238: + return ts.visitEachChild(node, asyncBodyVisitor, context); + default: + return ts.Debug.assertNever(node, "Unhandled node."); + } + } + return visitor(node); + } + function visitCatchClauseInAsyncBody(node) { + var catchClauseNames = ts.createUnderscoreEscapedMap(); + recordDeclarationName(node.variableDeclaration, catchClauseNames); + var catchClauseUnshadowedNames; + catchClauseNames.forEach(function (_, escapedName) { + if (enclosingFunctionParameterNames.has(escapedName)) { + if (!catchClauseUnshadowedNames) { + catchClauseUnshadowedNames = ts.cloneMap(enclosingFunctionParameterNames); + } + catchClauseUnshadowedNames.delete(escapedName); + } + }); + if (catchClauseUnshadowedNames) { + var savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames; + enclosingFunctionParameterNames = catchClauseUnshadowedNames; + var result = ts.visitEachChild(node, asyncBodyVisitor, context); + enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames; + return result; + } + else { + return ts.visitEachChild(node, asyncBodyVisitor, context); + } + } + function visitVariableStatementInAsyncBody(node) { + if (isVariableDeclarationListWithCollidingName(node.declarationList)) { + var expression = visitVariableDeclarationListWithCollidingNames(node.declarationList, false); + return expression ? ts.createExpressionStatement(expression) : undefined; + } + return ts.visitEachChild(node, visitor, context); + } + function visitForInStatementInAsyncBody(node) { + return ts.updateForIn(node, isVariableDeclarationListWithCollidingName(node.initializer) + ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitForOfStatementInAsyncBody(node) { + return ts.updateForOf(node, ts.visitNode(node.awaitModifier, visitor, ts.isToken), isVariableDeclarationListWithCollidingName(node.initializer) + ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitForStatementInAsyncBody(node) { + var initializer = node.initializer; + return ts.updateFor(node, isVariableDeclarationListWithCollidingName(initializer) + ? visitVariableDeclarationListWithCollidingNames(initializer, false) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitAwaitExpression(node) { + if (inTopLevelContext()) { + return ts.visitEachChild(node, visitor, context); + } + return ts.setOriginalNode(ts.setTextRange(ts.createYield(undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node); + } + function visitMethodDeclaration(node) { + return ts.updateMethod(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2 + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + function visitFunctionDeclaration(node) { + return ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2 + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + function visitFunctionExpression(node) { + return ts.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2 + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + function visitArrowFunction(node) { + return ts.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.getFunctionFlags(node) & 2 + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + function recordDeclarationName(_a, names) { + var name = _a.name; + if (ts.isIdentifier(name)) { + names.set(name.escapedText, true); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element)) { + recordDeclarationName(element, names); + } + } + } + } + function isVariableDeclarationListWithCollidingName(node) { + return !!node + && ts.isVariableDeclarationList(node) + && !(node.flags & 3) + && node.declarations.some(collidesWithParameterName); + } + function visitVariableDeclarationListWithCollidingNames(node, hasReceiver) { + hoistVariableDeclarationList(node); + var variables = ts.getInitializedVariables(node); + if (variables.length === 0) { + if (hasReceiver) { + return ts.visitNode(ts.convertToAssignmentElementTarget(node.declarations[0].name), visitor, ts.isExpression); + } + return undefined; + } + return ts.inlineExpressions(ts.map(variables, transformInitializedVariable)); + } + function hoistVariableDeclarationList(node) { + ts.forEach(node.declarations, hoistVariable); + } + function hoistVariable(_a) { + var name = _a.name; + if (ts.isIdentifier(name)) { + hoistVariableDeclaration(name); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element)) { + hoistVariable(element); + } + } + } + } + function transformInitializedVariable(node) { + var converted = ts.setSourceMapRange(ts.createAssignment(ts.convertToAssignmentElementTarget(node.name), node.initializer), node); + return ts.visitNode(converted, visitor, ts.isExpression); + } + function collidesWithParameterName(_a) { + var name = _a.name; + if (ts.isIdentifier(name)) { + return enclosingFunctionParameterNames.has(name.escapedText); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element) && collidesWithParameterName(element)) { + return true; + } + } + } + return false; + } + function transformAsyncFunctionBody(node) { + resumeLexicalEnvironment(); + var original = ts.getOriginalNode(node, ts.isFunctionLike); + var nodeType = original.type; + var promiseConstructor = languageVersion < 2 ? getPromiseConstructor(nodeType) : undefined; + var isArrowFunction = node.kind === 202; + var hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192) !== 0; + var savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames; + enclosingFunctionParameterNames = ts.createUnderscoreEscapedMap(); + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + recordDeclarationName(parameter, enclosingFunctionParameterNames); + } + var savedCapturedSuperProperties = capturedSuperProperties; + var savedHasSuperElementAccess = hasSuperElementAccess; + if (!isArrowFunction) { + capturedSuperProperties = ts.createUnderscoreEscapedMap(); + hasSuperElementAccess = false; + } + var result; + if (!isArrowFunction) { + var statements = []; + var statementOffset = ts.addPrologue(statements, node.body.statements, false, visitor); + statements.push(ts.createReturn(createAwaiterHelper(context, inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body, statementOffset)))); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var emitSuperHelpers = languageVersion >= 2 && resolver.getNodeCheckFlags(node) & (4096 | 2048); + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + if (ts.hasEntries(capturedSuperProperties)) { + var variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); + substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true; + ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]); + } + } + var block = ts.createBlock(statements, true); + ts.setTextRange(block, node.body); + if (emitSuperHelpers && hasSuperElementAccess) { + if (resolver.getNodeCheckFlags(node) & 4096) { + ts.addEmitHelper(block, ts.advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & 2048) { + ts.addEmitHelper(block, ts.asyncSuperHelper); + } + } + result = block; + } + else { + var expression = createAwaiterHelper(context, inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body)); + var declarations = endLexicalEnvironment(); + if (ts.some(declarations)) { + var block = ts.convertToFunctionBody(expression); + result = ts.updateBlock(block, ts.setTextRange(ts.createNodeArray(ts.concatenate(declarations, block.statements)), block.statements)); + } + else { + result = expression; + } + } + enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames; + if (!isArrowFunction) { + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + } + return result; + } + function transformAsyncFunctionBodyWorker(body, start) { + if (ts.isBlock(body)) { + return ts.updateBlock(body, ts.visitNodes(body.statements, asyncBodyVisitor, ts.isStatement, start)); + } + else { + return ts.convertToFunctionBody(ts.visitNode(body, asyncBodyVisitor, ts.isConciseBody)); + } + } + function getPromiseConstructor(type) { + var typeName = type && ts.getEntityNameFromTypeNode(type); + if (typeName && ts.isEntityName(typeName)) { + var serializationKind = resolver.getTypeReferenceSerializationKind(typeName); + if (serializationKind === ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue + || serializationKind === ts.TypeReferenceSerializationKind.Unknown) { + return typeName; + } + } + return undefined; + } + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & 1) === 0) { + enabledSubstitutions |= 1; + context.enableSubstitution(196); + context.enableSubstitution(194); + context.enableSubstitution(195); + context.enableEmitNotification(245); + context.enableEmitNotification(161); + context.enableEmitNotification(163); + context.enableEmitNotification(164); + context.enableEmitNotification(162); + context.enableEmitNotification(225); + } + } + function onEmitNode(hint, node, emitCallback) { + if (enabledSubstitutions & 1 && isSuperContainer(node)) { + var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 | 4096); + if (superContainerFlags !== enclosingSuperContainerFlags) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + else if (enabledSubstitutions && substitutedSuperAccessors[ts.getNodeId(node)]) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 194: + return substitutePropertyAccessExpression(node); + case 195: + return substituteElementAccessExpression(node); + case 196: + return substituteCallExpression(node); + } + return node; + } + function substitutePropertyAccessExpression(node) { + if (node.expression.kind === 102) { + return ts.setTextRange(ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), node.name), node); + } + return node; + } + function substituteElementAccessExpression(node) { + if (node.expression.kind === 102) { + return createSuperElementAccessInAsyncMethod(node.argumentExpression, node); + } + return node; + } + function substituteCallExpression(node) { + var expression = node.expression; + if (ts.isSuperProperty(expression)) { + var argumentExpression = ts.isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return ts.createCall(ts.createPropertyAccess(argumentExpression, "call"), undefined, __spreadArrays([ + ts.createThis() + ], node.arguments)); + } + return node; + } + function isSuperContainer(node) { + var kind = node.kind; + return kind === 245 + || kind === 162 + || kind === 161 + || kind === 163 + || kind === 164; + } + function createSuperElementAccessInAsyncMethod(argumentExpression, location) { + if (enclosingSuperContainerFlags & 4096) { + return ts.setTextRange(ts.createPropertyAccess(ts.createCall(ts.createFileLevelUniqueName("_superIndex"), undefined, [argumentExpression]), "value"), location); + } + else { + return ts.setTextRange(ts.createCall(ts.createFileLevelUniqueName("_superIndex"), undefined, [argumentExpression]), location); + } + } + } + ts.transformES2017 = transformES2017; + function createSuperAccessVariableStatement(resolver, node, names) { + var hasBinding = (resolver.getNodeCheckFlags(node) & 4096) !== 0; + var accessors = []; + names.forEach(function (_, key) { + var name = ts.unescapeLeadingUnderscores(key); + var getterAndSetter = []; + getterAndSetter.push(ts.createPropertyAssignment("get", ts.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.setEmitFlags(ts.createPropertyAccess(ts.setEmitFlags(ts.createSuper(), 4), name), 4)))); + if (hasBinding) { + getterAndSetter.push(ts.createPropertyAssignment("set", ts.createArrowFunction(undefined, undefined, [ + ts.createParameter(undefined, undefined, undefined, "v", undefined, undefined, undefined) + ], undefined, undefined, ts.createAssignment(ts.setEmitFlags(ts.createPropertyAccess(ts.setEmitFlags(ts.createSuper(), 4), name), 4), ts.createIdentifier("v"))))); + } + accessors.push(ts.createPropertyAssignment(name, ts.createObjectLiteral(getterAndSetter))); + }); + return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.createFileLevelUniqueName("_super"), undefined, ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "create"), undefined, [ + ts.createNull(), + ts.createObjectLiteral(accessors, true) + ])) + ], 2)); + } + ts.createSuperAccessVariableStatement = createSuperAccessVariableStatement; + ts.awaiterHelper = { + name: "typescript:awaiter", + importName: "__awaiter", + scoped: false, + priority: 5, + text: "\n var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n };" + }; + function createAwaiterHelper(context, hasLexicalThis, hasLexicalArguments, promiseConstructor, body) { + context.requestEmitHelper(ts.awaiterHelper); + var generatorFunc = ts.createFunctionExpression(undefined, ts.createToken(41), undefined, undefined, [], undefined, body); + (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 | 524288; + return ts.createCall(ts.getUnscopedHelperName("__awaiter"), undefined, [ + hasLexicalThis ? ts.createThis() : ts.createVoidZero(), + hasLexicalArguments ? ts.createIdentifier("arguments") : ts.createVoidZero(), + promiseConstructor ? ts.createExpressionFromEntityName(promiseConstructor) : ts.createVoidZero(), + generatorFunc + ]); + } + ts.asyncSuperHelper = { + name: "typescript:async-super", + scoped: true, + text: ts.helperString(__makeTemplateObject(["\n const ", " = name => super[name];"], ["\n const ", " = name => super[name];"]), "_superIndex") + }; + ts.advancedAsyncSuperHelper = { + name: "typescript:advanced-async-super", + scoped: true, + text: ts.helperString(__makeTemplateObject(["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"], ["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"]), "_superIndex") + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2018(context) { + var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var exportedVariableStatement = false; + var enabledSubstitutions; + var enclosingFunctionFlags; + var enclosingSuperContainerFlags = 0; + var hasLexicalThis; + var capturedSuperProperties; + var hasSuperElementAccess; + var substitutedSuperAccessors = []; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + exportedVariableStatement = false; + hasLexicalThis = !ts.isEffectiveStrictModeSourceFile(node, compilerOptions); + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function visitor(node) { + return visitorWorker(node, false); + } + function visitorNoDestructuringValue(node) { + return visitorWorker(node, true); + } + function visitorNoAsyncModifier(node) { + if (node.kind === 126) { + return undefined; + } + return node; + } + function doWithLexicalThis(cb, value) { + if (!hasLexicalThis) { + hasLexicalThis = true; + var result = cb(value); + hasLexicalThis = false; + return result; + } + return cb(value); + } + function visitDefault(node) { + return ts.visitEachChild(node, visitor, context); + } + function visitorWorker(node, noDestructuringValue) { + if ((node.transformFlags & 32) === 0) { + return node; + } + switch (node.kind) { + case 206: + return visitAwaitExpression(node); + case 212: + return visitYieldExpression(node); + case 235: + return visitReturnStatement(node); + case 238: + return visitLabeledStatement(node); + case 193: + return visitObjectLiteralExpression(node); + case 209: + return visitBinaryExpression(node, noDestructuringValue); + case 280: + return visitCatchClause(node); + case 225: + return visitVariableStatement(node); + case 242: + return visitVariableDeclaration(node); + case 232: + return visitForOfStatement(node, undefined); + case 230: + return visitForStatement(node); + case 205: + return visitVoidExpression(node); + case 162: + return doWithLexicalThis(visitConstructorDeclaration, node); + case 161: + return doWithLexicalThis(visitMethodDeclaration, node); + case 163: + return doWithLexicalThis(visitGetAccessorDeclaration, node); + case 164: + return doWithLexicalThis(visitSetAccessorDeclaration, node); + case 244: + return doWithLexicalThis(visitFunctionDeclaration, node); + case 201: + return doWithLexicalThis(visitFunctionExpression, node); + case 202: + return visitArrowFunction(node); + case 156: + return visitParameter(node); + case 226: + return visitExpressionStatement(node); + case 200: + return visitParenthesizedExpression(node, noDestructuringValue); + case 194: + if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 102) { + capturedSuperProperties.set(node.name.escapedText, true); + } + return ts.visitEachChild(node, visitor, context); + case 195: + if (capturedSuperProperties && node.expression.kind === 102) { + hasSuperElementAccess = true; + } + return ts.visitEachChild(node, visitor, context); + case 245: + case 214: + return doWithLexicalThis(visitDefault, node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitAwaitExpression(node) { + if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) { + return ts.setOriginalNode(ts.setTextRange(ts.createYield(createAwaitHelper(context, ts.visitNode(node.expression, visitor, ts.isExpression))), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitYieldExpression(node) { + if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) { + if (node.asteriskToken) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + return ts.setOriginalNode(ts.setTextRange(ts.createYield(createAwaitHelper(context, ts.updateYield(node, node.asteriskToken, createAsyncDelegatorHelper(context, createAsyncValuesHelper(context, expression, expression), expression)))), node), node); + } + return ts.setOriginalNode(ts.setTextRange(ts.createYield(createDownlevelAwait(node.expression + ? ts.visitNode(node.expression, visitor, ts.isExpression) + : ts.createVoidZero())), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitReturnStatement(node) { + if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) { + return ts.updateReturn(node, createDownlevelAwait(node.expression ? ts.visitNode(node.expression, visitor, ts.isExpression) : ts.createVoidZero())); + } + return ts.visitEachChild(node, visitor, context); + } + function visitLabeledStatement(node) { + if (enclosingFunctionFlags & 2) { + var statement = ts.unwrapInnermostStatementOfLabel(node); + if (statement.kind === 232 && statement.awaitModifier) { + return visitForOfStatement(statement, node); + } + return ts.restoreEnclosingLabel(ts.visitEachChild(statement, visitor, context), node); + } + return ts.visitEachChild(node, visitor, context); + } + function chunkObjectLiteralElements(elements) { + var chunkObject; + var objects = []; + for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) { + var e = elements_4[_i]; + if (e.kind === 283) { + if (chunkObject) { + objects.push(ts.createObjectLiteral(chunkObject)); + chunkObject = undefined; + } + var target = e.expression; + objects.push(ts.visitNode(target, visitor, ts.isExpression)); + } + else { + chunkObject = ts.append(chunkObject, e.kind === 281 + ? ts.createPropertyAssignment(e.name, ts.visitNode(e.initializer, visitor, ts.isExpression)) + : ts.visitNode(e, visitor, ts.isObjectLiteralElementLike)); + } + } + if (chunkObject) { + objects.push(ts.createObjectLiteral(chunkObject)); + } + return objects; + } + function visitObjectLiteralExpression(node) { + if (node.transformFlags & 16384) { + var objects = chunkObjectLiteralElements(node.properties); + if (objects.length && objects[0].kind !== 193) { + objects.unshift(ts.createObjectLiteral()); + } + var expression = objects[0]; + if (objects.length > 1) { + for (var i = 1; i < objects.length; i++) { + expression = createAssignHelper(context, [expression, objects[i]]); + } + return expression; + } + else { + return createAssignHelper(context, objects); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitExpressionStatement(node) { + return ts.visitEachChild(node, visitorNoDestructuringValue, context); + } + function visitParenthesizedExpression(node, noDestructuringValue) { + return ts.visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context); + } + function visitBinaryExpression(node, noDestructuringValue) { + if (ts.isDestructuringAssignment(node) && node.left.transformFlags & 16384) { + return ts.flattenDestructuringAssignment(node, visitor, context, 1, !noDestructuringValue); + } + else if (node.operatorToken.kind === 27) { + return ts.updateBinary(node, ts.visitNode(node.left, visitorNoDestructuringValue, ts.isExpression), ts.visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitCatchClause(node) { + if (node.variableDeclaration && + ts.isBindingPattern(node.variableDeclaration.name) && + node.variableDeclaration.name.transformFlags & 16384) { + var name = ts.getGeneratedNameForNode(node.variableDeclaration.name); + var updatedDecl = ts.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, undefined, name); + var visitedBindings = ts.flattenDestructuringBinding(updatedDecl, visitor, context, 1); + var block = ts.visitNode(node.block, visitor, ts.isBlock); + if (ts.some(visitedBindings)) { + block = ts.updateBlock(block, __spreadArrays([ + ts.createVariableStatement(undefined, visitedBindings) + ], block.statements)); + } + return ts.updateCatchClause(node, ts.updateVariableDeclaration(node.variableDeclaration, name, undefined, undefined), block); + } + return ts.visitEachChild(node, visitor, context); + } + function visitVariableStatement(node) { + if (ts.hasModifier(node, 1)) { + var savedExportedVariableStatement = exportedVariableStatement; + exportedVariableStatement = true; + var visited = ts.visitEachChild(node, visitor, context); + exportedVariableStatement = savedExportedVariableStatement; + return visited; + } + return ts.visitEachChild(node, visitor, context); + } + function visitVariableDeclaration(node) { + if (exportedVariableStatement) { + var savedExportedVariableStatement = exportedVariableStatement; + exportedVariableStatement = false; + var visited = visitVariableDeclarationWorker(node, true); + exportedVariableStatement = savedExportedVariableStatement; + return visited; + } + return visitVariableDeclarationWorker(node, false); + } + function visitVariableDeclarationWorker(node, exportedVariableStatement) { + if (ts.isBindingPattern(node.name) && node.name.transformFlags & 16384) { + return ts.flattenDestructuringBinding(node, visitor, context, 1, undefined, exportedVariableStatement); + } + return ts.visitEachChild(node, visitor, context); + } + function visitForStatement(node) { + return ts.updateFor(node, ts.visitNode(node.initializer, visitorNoDestructuringValue, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement)); + } + function visitVoidExpression(node) { + return ts.visitEachChild(node, visitorNoDestructuringValue, context); + } + function visitForOfStatement(node, outermostLabeledStatement) { + if (node.initializer.transformFlags & 16384) { + node = transformForOfStatementWithObjectRest(node); + } + if (node.awaitModifier) { + return transformForAwaitOfStatement(node, outermostLabeledStatement); + } + else { + return ts.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement); + } + } + function transformForOfStatementWithObjectRest(node) { + var initializerWithoutParens = ts.skipParentheses(node.initializer); + if (ts.isVariableDeclarationList(initializerWithoutParens) || ts.isAssignmentPattern(initializerWithoutParens)) { + var bodyLocation = void 0; + var statementsLocation = void 0; + var temp = ts.createTempVariable(undefined); + var statements = [ts.createForOfBindingStatement(initializerWithoutParens, temp)]; + if (ts.isBlock(node.statement)) { + ts.addRange(statements, node.statement.statements); + bodyLocation = node.statement; + statementsLocation = node.statement.statements; + } + else if (node.statement) { + ts.append(statements, node.statement); + bodyLocation = node.statement; + statementsLocation = node.statement; + } + return ts.updateForOf(node, node.awaitModifier, ts.setTextRange(ts.createVariableDeclarationList([ + ts.setTextRange(ts.createVariableDeclaration(temp), node.initializer) + ], 1), node.initializer), node.expression, ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true), bodyLocation)); + } + return node; + } + function convertForOfStatementHead(node, boundValue) { + var binding = ts.createForOfBindingStatement(node.initializer, boundValue); + var bodyLocation; + var statementsLocation; + var statements = [ts.visitNode(binding, visitor, ts.isStatement)]; + var statement = ts.visitNode(node.statement, visitor, ts.isStatement); + if (ts.isBlock(statement)) { + ts.addRange(statements, statement.statements); + bodyLocation = statement; + statementsLocation = statement.statements; + } + else { + statements.push(statement); + } + return ts.setEmitFlags(ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384); + } + function createDownlevelAwait(expression) { + return enclosingFunctionFlags & 1 + ? ts.createYield(undefined, createAwaitHelper(context, expression)) + : ts.createAwait(expression); + } + function transformForAwaitOfStatement(node, outermostLabeledStatement) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var iterator = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined); + var result = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(iterator) : ts.createTempVariable(undefined); + var errorRecord = ts.createUniqueName("e"); + var catchVariable = ts.getGeneratedNameForNode(errorRecord); + var returnMethod = ts.createTempVariable(undefined); + var callValues = createAsyncValuesHelper(context, expression, node.expression); + var callNext = ts.createCall(ts.createPropertyAccess(iterator, "next"), undefined, []); + var getDone = ts.createPropertyAccess(result, "done"); + var getValue = ts.createPropertyAccess(result, "value"); + var callReturn = ts.createFunctionCall(returnMethod, iterator, []); + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + var forStatement = ts.setEmitFlags(ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([ + ts.setTextRange(ts.createVariableDeclaration(iterator, undefined, callValues), node.expression), + ts.createVariableDeclaration(result) + ]), node.expression), 2097152), ts.createComma(ts.createAssignment(result, createDownlevelAwait(callNext)), ts.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256); + return ts.createTry(ts.createBlock([ + ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement) + ]), ts.createCatchClause(ts.createVariableDeclaration(catchVariable), ts.setEmitFlags(ts.createBlock([ + ts.createExpressionStatement(ts.createAssignment(errorRecord, ts.createObjectLiteral([ + ts.createPropertyAssignment("error", catchVariable) + ]))) + ]), 1)), ts.createBlock([ + ts.createTry(ts.createBlock([ + ts.setEmitFlags(ts.createIf(ts.createLogicalAnd(ts.createLogicalAnd(result, ts.createLogicalNot(getDone)), ts.createAssignment(returnMethod, ts.createPropertyAccess(iterator, "return"))), ts.createExpressionStatement(createDownlevelAwait(callReturn))), 1) + ]), undefined, ts.setEmitFlags(ts.createBlock([ + ts.setEmitFlags(ts.createIf(errorRecord, ts.createThrow(ts.createPropertyAccess(errorRecord, "error"))), 1) + ]), 1)) + ])); + } + function visitParameter(node) { + if (node.transformFlags & 16384) { + return ts.updateParameter(node, undefined, undefined, node.dotDotDotToken, ts.getGeneratedNameForNode(node), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitConstructorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = 0; + var updated = ts.updateConstructor(node, undefined, node.modifiers, ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitGetAccessorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = 0; + var updated = ts.updateGetAccessor(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitSetAccessorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = 0; + var updated = ts.updateSetAccessor(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitMethodDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = ts.getFunctionFlags(node); + var updated = ts.updateMethod(node, undefined, enclosingFunctionFlags & 1 + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier) + : node.modifiers, enclosingFunctionFlags & 2 + ? undefined + : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(undefined, visitor, ts.isToken), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1 + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitFunctionDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = ts.getFunctionFlags(node); + var updated = ts.updateFunctionDeclaration(node, undefined, enclosingFunctionFlags & 1 + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier) + : node.modifiers, enclosingFunctionFlags & 2 + ? undefined + : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1 + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitArrowFunction(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = ts.getFunctionFlags(node); + var updated = ts.updateArrowFunction(node, node.modifiers, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function visitFunctionExpression(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = ts.getFunctionFlags(node); + var updated = ts.updateFunctionExpression(node, enclosingFunctionFlags & 1 + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier) + : node.modifiers, enclosingFunctionFlags & 2 + ? undefined + : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1 + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + function transformAsyncGeneratorFunctionBody(node) { + resumeLexicalEnvironment(); + var statements = []; + var statementOffset = ts.addPrologue(statements, node.body.statements, false, visitor); + appendObjectRestAssignmentsIfNeeded(statements, node); + var savedCapturedSuperProperties = capturedSuperProperties; + var savedHasSuperElementAccess = hasSuperElementAccess; + capturedSuperProperties = ts.createUnderscoreEscapedMap(); + hasSuperElementAccess = false; + var returnStatement = ts.createReturn(createAsyncGeneratorHelper(context, ts.createFunctionExpression(undefined, ts.createToken(41), node.name && ts.getGeneratedNameForNode(node.name), undefined, [], undefined, ts.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), hasLexicalThis)); + var emitSuperHelpers = languageVersion >= 2 && resolver.getNodeCheckFlags(node) & (4096 | 2048); + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + var variableStatement = ts.createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); + substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true; + ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]); + } + statements.push(returnStatement); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var block = ts.updateBlock(node.body, statements); + if (emitSuperHelpers && hasSuperElementAccess) { + if (resolver.getNodeCheckFlags(node) & 4096) { + ts.addEmitHelper(block, ts.advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & 2048) { + ts.addEmitHelper(block, ts.asyncSuperHelper); + } + } + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + return block; + } + function transformFunctionBody(node) { + resumeLexicalEnvironment(); + var statementOffset = 0; + var statements = []; + var body = ts.visitNode(node.body, visitor, ts.isConciseBody); + if (ts.isBlock(body)) { + statementOffset = ts.addPrologue(statements, body.statements, false, visitor); + } + ts.addRange(statements, appendObjectRestAssignmentsIfNeeded(undefined, node)); + var leadingStatements = endLexicalEnvironment(); + if (statementOffset > 0 || ts.some(statements) || ts.some(leadingStatements)) { + var block = ts.convertToFunctionBody(body, true); + ts.insertStatementsAfterStandardPrologue(statements, leadingStatements); + ts.addRange(statements, block.statements.slice(statementOffset)); + return ts.updateBlock(block, ts.setTextRange(ts.createNodeArray(statements), block.statements)); + } + return body; + } + function appendObjectRestAssignmentsIfNeeded(statements, node) { + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + if (parameter.transformFlags & 16384) { + var temp = ts.getGeneratedNameForNode(parameter); + var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1, temp, false, true); + if (ts.some(declarations)) { + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList(declarations)); + ts.setEmitFlags(statement, 1048576); + statements = ts.append(statements, statement); + } + } + } + return statements; + } + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & 1) === 0) { + enabledSubstitutions |= 1; + context.enableSubstitution(196); + context.enableSubstitution(194); + context.enableSubstitution(195); + context.enableEmitNotification(245); + context.enableEmitNotification(161); + context.enableEmitNotification(163); + context.enableEmitNotification(164); + context.enableEmitNotification(162); + context.enableEmitNotification(225); + } + } + function onEmitNode(hint, node, emitCallback) { + if (enabledSubstitutions & 1 && isSuperContainer(node)) { + var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 | 4096); + if (superContainerFlags !== enclosingSuperContainerFlags) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + else if (enabledSubstitutions && substitutedSuperAccessors[ts.getNodeId(node)]) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 194: + return substitutePropertyAccessExpression(node); + case 195: + return substituteElementAccessExpression(node); + case 196: + return substituteCallExpression(node); + } + return node; + } + function substitutePropertyAccessExpression(node) { + if (node.expression.kind === 102) { + return ts.setTextRange(ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), node.name), node); + } + return node; + } + function substituteElementAccessExpression(node) { + if (node.expression.kind === 102) { + return createSuperElementAccessInAsyncMethod(node.argumentExpression, node); + } + return node; + } + function substituteCallExpression(node) { + var expression = node.expression; + if (ts.isSuperProperty(expression)) { + var argumentExpression = ts.isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return ts.createCall(ts.createPropertyAccess(argumentExpression, "call"), undefined, __spreadArrays([ + ts.createThis() + ], node.arguments)); + } + return node; + } + function isSuperContainer(node) { + var kind = node.kind; + return kind === 245 + || kind === 162 + || kind === 161 + || kind === 163 + || kind === 164; + } + function createSuperElementAccessInAsyncMethod(argumentExpression, location) { + if (enclosingSuperContainerFlags & 4096) { + return ts.setTextRange(ts.createPropertyAccess(ts.createCall(ts.createIdentifier("_superIndex"), undefined, [argumentExpression]), "value"), location); + } + else { + return ts.setTextRange(ts.createCall(ts.createIdentifier("_superIndex"), undefined, [argumentExpression]), location); + } + } + } + ts.transformES2018 = transformES2018; + ts.assignHelper = { + name: "typescript:assign", + importName: "__assign", + scoped: false, + priority: 1, + text: "\n var __assign = (this && this.__assign) || function () {\n __assign = Object.assign || function(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n };" + }; + function createAssignHelper(context, attributesSegments) { + if (context.getCompilerOptions().target >= 2) { + return ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "assign"), undefined, attributesSegments); + } + context.requestEmitHelper(ts.assignHelper); + return ts.createCall(ts.getUnscopedHelperName("__assign"), undefined, attributesSegments); + } + ts.createAssignHelper = createAssignHelper; + ts.awaitHelper = { + name: "typescript:await", + importName: "__await", + scoped: false, + text: "\n var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }" + }; + function createAwaitHelper(context, expression) { + context.requestEmitHelper(ts.awaitHelper); + return ts.createCall(ts.getUnscopedHelperName("__await"), undefined, [expression]); + } + ts.asyncGeneratorHelper = { + name: "typescript:asyncGenerator", + importName: "__asyncGenerator", + scoped: false, + text: "\n var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n };" + }; + function createAsyncGeneratorHelper(context, generatorFunc, hasLexicalThis) { + context.requestEmitHelper(ts.awaitHelper); + context.requestEmitHelper(ts.asyncGeneratorHelper); + (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144; + return ts.createCall(ts.getUnscopedHelperName("__asyncGenerator"), undefined, [ + hasLexicalThis ? ts.createThis() : ts.createVoidZero(), + ts.createIdentifier("arguments"), + generatorFunc + ]); + } + ts.asyncDelegator = { + name: "typescript:asyncDelegator", + importName: "__asyncDelegator", + scoped: false, + text: "\n var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\n };" + }; + function createAsyncDelegatorHelper(context, expression, location) { + context.requestEmitHelper(ts.awaitHelper); + context.requestEmitHelper(ts.asyncDelegator); + return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__asyncDelegator"), undefined, [expression]), location); + } + ts.asyncValues = { + name: "typescript:asyncValues", + importName: "__asyncValues", + scoped: false, + text: "\n var __asyncValues = (this && this.__asyncValues) || function (o) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n };" + }; + function createAsyncValuesHelper(context, expression, location) { + context.requestEmitHelper(ts.asyncValues); + return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__asyncValues"), undefined, [expression]), location); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2019(context) { + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 16) === 0) { + return node; + } + switch (node.kind) { + case 280: + return visitCatchClause(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitCatchClause(node) { + if (!node.variableDeclaration) { + return ts.updateCatchClause(node, ts.createVariableDeclaration(ts.createTempVariable(undefined)), ts.visitNode(node.block, visitor, ts.isBlock)); + } + return ts.visitEachChild(node, visitor, context); + } + } + ts.transformES2019 = transformES2019; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2020(context) { + var hoistVariableDeclaration = context.hoistVariableDeclaration; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 8) === 0) { + return node; + } + switch (node.kind) { + case 194: + case 195: + case 196: + if (node.flags & 32) { + var updated = visitOptionalExpression(node, false, false); + ts.Debug.assertNotNode(updated, ts.isSyntheticReference); + return updated; + } + return ts.visitEachChild(node, visitor, context); + case 209: + if (node.operatorToken.kind === 60) { + return transformNullishCoalescingExpression(node); + } + return ts.visitEachChild(node, visitor, context); + case 203: + return visitDeleteExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function flattenChain(chain) { + var links = [chain]; + while (!chain.questionDotToken && !ts.isTaggedTemplateExpression(chain)) { + chain = ts.cast(chain.expression, ts.isOptionalChain); + links.unshift(chain); + } + return { expression: chain.expression, chain: links }; + } + function visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete) { + var expression = visitNonOptionalExpression(node.expression, captureThisArg, isDelete); + if (ts.isSyntheticReference(expression)) { + return ts.createSyntheticReferenceExpression(ts.updateParen(node, expression.expression), expression.thisArg); + } + return ts.updateParen(node, expression); + } + function visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete) { + if (ts.isOptionalChain(node)) { + return visitOptionalExpression(node, captureThisArg, isDelete); + } + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + ts.Debug.assertNotNode(expression, ts.isSyntheticReference); + var thisArg; + if (captureThisArg) { + if (shouldCaptureInTempVariable(expression)) { + thisArg = ts.createTempVariable(hoistVariableDeclaration); + expression = ts.createAssignment(thisArg, expression); + } + else { + thisArg = expression; + } + } + expression = node.kind === 194 + ? ts.updatePropertyAccess(node, expression, ts.visitNode(node.name, visitor, ts.isIdentifier)) + : ts.updateElementAccess(node, expression, ts.visitNode(node.argumentExpression, visitor, ts.isExpression)); + return thisArg ? ts.createSyntheticReferenceExpression(expression, thisArg) : expression; + } + function visitNonOptionalCallExpression(node, captureThisArg) { + if (ts.isOptionalChain(node)) { + return visitOptionalExpression(node, captureThisArg, false); + } + return ts.visitEachChild(node, visitor, context); + } + function visitNonOptionalExpression(node, captureThisArg, isDelete) { + switch (node.kind) { + case 200: return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete); + case 194: + case 195: return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete); + case 196: return visitNonOptionalCallExpression(node, captureThisArg); + default: return ts.visitNode(node, visitor, ts.isExpression); + } + } + function visitOptionalExpression(node, captureThisArg, isDelete) { + var _a = flattenChain(node), expression = _a.expression, chain = _a.chain; + var left = visitNonOptionalExpression(expression, ts.isCallChain(chain[0]), false); + var leftThisArg = ts.isSyntheticReference(left) ? left.thisArg : undefined; + var leftExpression = ts.isSyntheticReference(left) ? left.expression : left; + var capturedLeft = leftExpression; + if (shouldCaptureInTempVariable(leftExpression)) { + capturedLeft = ts.createTempVariable(hoistVariableDeclaration); + leftExpression = ts.createAssignment(capturedLeft, leftExpression); + } + var rightExpression = capturedLeft; + var thisArg; + for (var i = 0; i < chain.length; i++) { + var segment = chain[i]; + switch (segment.kind) { + case 194: + case 195: + if (i === chain.length - 1 && captureThisArg) { + if (shouldCaptureInTempVariable(rightExpression)) { + thisArg = ts.createTempVariable(hoistVariableDeclaration); + rightExpression = ts.createAssignment(thisArg, rightExpression); + } + else { + thisArg = rightExpression; + } + } + rightExpression = segment.kind === 194 + ? ts.createPropertyAccess(rightExpression, ts.visitNode(segment.name, visitor, ts.isIdentifier)) + : ts.createElementAccess(rightExpression, ts.visitNode(segment.argumentExpression, visitor, ts.isExpression)); + break; + case 196: + if (i === 0 && leftThisArg) { + rightExpression = ts.createFunctionCall(rightExpression, leftThisArg.kind === 102 ? ts.createThis() : leftThisArg, ts.visitNodes(segment.arguments, visitor, ts.isExpression)); + } + else { + rightExpression = ts.createCall(rightExpression, undefined, ts.visitNodes(segment.arguments, visitor, ts.isExpression)); + } + break; + } + ts.setOriginalNode(rightExpression, segment); + } + var target = isDelete + ? ts.createConditional(createNotNullCondition(leftExpression, capturedLeft, true), ts.createTrue(), ts.createDelete(rightExpression)) + : ts.createConditional(createNotNullCondition(leftExpression, capturedLeft, true), ts.createVoidZero(), rightExpression); + return thisArg ? ts.createSyntheticReferenceExpression(target, thisArg) : target; + } + function createNotNullCondition(left, right, invert) { + return ts.createBinary(ts.createBinary(left, ts.createToken(invert ? 36 : 37), ts.createNull()), ts.createToken(invert ? 56 : 55), ts.createBinary(right, ts.createToken(invert ? 36 : 37), ts.createVoidZero())); + } + function transformNullishCoalescingExpression(node) { + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = left; + if (shouldCaptureInTempVariable(left)) { + right = ts.createTempVariable(hoistVariableDeclaration); + left = ts.createAssignment(right, left); + } + return ts.createConditional(createNotNullCondition(left, right), right, ts.visitNode(node.right, visitor, ts.isExpression)); + } + function shouldCaptureInTempVariable(expression) { + return !ts.isIdentifier(expression) && + expression.kind !== 104 && + expression.kind !== 102; + } + function visitDeleteExpression(node) { + return ts.isOptionalChain(ts.skipParentheses(node.expression)) + ? ts.setOriginalNode(visitNonOptionalExpression(node.expression, false, true), node) + : ts.updateDelete(node, ts.visitNode(node.expression, visitor, ts.isExpression)); + } + } + ts.transformES2020 = transformES2020; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformESNext(context) { + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 4) === 0) { + return node; + } + switch (node.kind) { + default: + return ts.visitEachChild(node, visitor, context); + } + } + } + ts.transformESNext = transformESNext; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformJsx(context) { + var compilerOptions = context.getCompilerOptions(); + var currentSourceFile; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function visitor(node) { + if (node.transformFlags & 2) { + return visitorWorker(node); + } + else { + return node; + } + } + function visitorWorker(node) { + switch (node.kind) { + case 266: + return visitJsxElement(node, false); + case 267: + return visitJsxSelfClosingElement(node, false); + case 270: + return visitJsxFragment(node, false); + case 276: + return visitJsxExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function transformJsxChildToExpression(node) { + switch (node.kind) { + case 11: + return visitJsxText(node); + case 276: + return visitJsxExpression(node); + case 266: + return visitJsxElement(node, true); + case 267: + return visitJsxSelfClosingElement(node, true); + case 270: + return visitJsxFragment(node, true); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function visitJsxElement(node, isChild) { + return visitJsxOpeningLikeElement(node.openingElement, node.children, isChild, node); + } + function visitJsxSelfClosingElement(node, isChild) { + return visitJsxOpeningLikeElement(node, undefined, isChild, node); + } + function visitJsxFragment(node, isChild) { + return visitJsxOpeningFragment(node.openingFragment, node.children, isChild, node); + } + function visitJsxOpeningLikeElement(node, children, isChild, location) { + var tagName = getTagName(node); + var objectProperties; + var attrs = node.attributes.properties; + if (attrs.length === 0) { + objectProperties = ts.createNull(); + } + else { + var segments = ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) { return isSpread + ? ts.map(attrs, transformJsxSpreadAttributeToExpression) + : ts.createObjectLiteral(ts.map(attrs, transformJsxAttributeToObjectLiteralElement)); })); + if (ts.isJsxSpreadAttribute(attrs[0])) { + segments.unshift(ts.createObjectLiteral()); + } + objectProperties = ts.singleOrUndefined(segments); + if (!objectProperties) { + objectProperties = ts.createAssignHelper(context, segments); + } + } + var element = ts.createExpressionForJsxElement(context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, tagName, objectProperties, ts.mapDefined(children, transformJsxChildToExpression), node, location); + if (isChild) { + ts.startOnNewLine(element); + } + return element; + } + function visitJsxOpeningFragment(node, children, isChild, location) { + var element = ts.createExpressionForJsxFragment(context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, ts.mapDefined(children, transformJsxChildToExpression), node, location); + if (isChild) { + ts.startOnNewLine(element); + } + return element; + } + function transformJsxSpreadAttributeToExpression(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + function transformJsxAttributeToObjectLiteralElement(node) { + var name = getAttributeName(node); + var expression = transformJsxAttributeInitializer(node.initializer); + return ts.createPropertyAssignment(name, expression); + } + function transformJsxAttributeInitializer(node) { + if (node === undefined) { + return ts.createTrue(); + } + else if (node.kind === 10) { + var literal = ts.createLiteral(tryDecodeEntities(node.text) || node.text); + literal.singleQuote = node.singleQuote !== undefined ? node.singleQuote : !ts.isStringDoubleQuoted(node, currentSourceFile); + return ts.setTextRange(literal, node); + } + else if (node.kind === 276) { + if (node.expression === undefined) { + return ts.createTrue(); + } + return visitJsxExpression(node); + } + else { + return ts.Debug.failBadSyntaxKind(node); + } + } + function visitJsxText(node) { + var fixed = fixupWhitespaceAndDecodeEntities(node.text); + return fixed === undefined ? undefined : ts.createLiteral(fixed); + } + function fixupWhitespaceAndDecodeEntities(text) { + var acc; + var firstNonWhitespace = 0; + var lastNonWhitespace = -1; + for (var i = 0; i < text.length; i++) { + var c = text.charCodeAt(i); + if (ts.isLineBreak(c)) { + if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) { + acc = addLineOfJsxText(acc, text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1)); + } + firstNonWhitespace = -1; + } + else if (!ts.isWhiteSpaceSingleLine(c)) { + lastNonWhitespace = i; + if (firstNonWhitespace === -1) { + firstNonWhitespace = i; + } + } + } + return firstNonWhitespace !== -1 + ? addLineOfJsxText(acc, text.substr(firstNonWhitespace)) + : acc; + } + function addLineOfJsxText(acc, trimmedLine) { + var decoded = decodeEntities(trimmedLine); + return acc === undefined ? decoded : acc + " " + decoded; + } + function decodeEntities(text) { + return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, function (match, _all, _number, _digits, decimal, hex, word) { + if (decimal) { + return ts.utf16EncodeAsString(parseInt(decimal, 10)); + } + else if (hex) { + return ts.utf16EncodeAsString(parseInt(hex, 16)); + } + else { + var ch = entities.get(word); + return ch ? ts.utf16EncodeAsString(ch) : match; + } + }); + } + function tryDecodeEntities(text) { + var decoded = decodeEntities(text); + return decoded === text ? undefined : decoded; + } + function getTagName(node) { + if (node.kind === 266) { + return getTagName(node.openingElement); + } + else { + var name = node.tagName; + if (ts.isIdentifier(name) && ts.isIntrinsicJsxName(name.escapedText)) { + return ts.createLiteral(ts.idText(name)); + } + else { + return ts.createExpressionFromEntityName(name); + } + } + } + function getAttributeName(node) { + var name = node.name; + var text = ts.idText(name); + if (/^[A-Za-z_]\w*$/.test(text)) { + return name; + } + else { + return ts.createLiteral(text); + } + } + function visitJsxExpression(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + } + ts.transformJsx = transformJsx; + var entities = ts.createMapFromTemplate({ + quot: 0x0022, + amp: 0x0026, + apos: 0x0027, + lt: 0x003C, + gt: 0x003E, + nbsp: 0x00A0, + iexcl: 0x00A1, + cent: 0x00A2, + pound: 0x00A3, + curren: 0x00A4, + yen: 0x00A5, + brvbar: 0x00A6, + sect: 0x00A7, + uml: 0x00A8, + copy: 0x00A9, + ordf: 0x00AA, + laquo: 0x00AB, + not: 0x00AC, + shy: 0x00AD, + reg: 0x00AE, + macr: 0x00AF, + deg: 0x00B0, + plusmn: 0x00B1, + sup2: 0x00B2, + sup3: 0x00B3, + acute: 0x00B4, + micro: 0x00B5, + para: 0x00B6, + middot: 0x00B7, + cedil: 0x00B8, + sup1: 0x00B9, + ordm: 0x00BA, + raquo: 0x00BB, + frac14: 0x00BC, + frac12: 0x00BD, + frac34: 0x00BE, + iquest: 0x00BF, + Agrave: 0x00C0, + Aacute: 0x00C1, + Acirc: 0x00C2, + Atilde: 0x00C3, + Auml: 0x00C4, + Aring: 0x00C5, + AElig: 0x00C6, + Ccedil: 0x00C7, + Egrave: 0x00C8, + Eacute: 0x00C9, + Ecirc: 0x00CA, + Euml: 0x00CB, + Igrave: 0x00CC, + Iacute: 0x00CD, + Icirc: 0x00CE, + Iuml: 0x00CF, + ETH: 0x00D0, + Ntilde: 0x00D1, + Ograve: 0x00D2, + Oacute: 0x00D3, + Ocirc: 0x00D4, + Otilde: 0x00D5, + Ouml: 0x00D6, + times: 0x00D7, + Oslash: 0x00D8, + Ugrave: 0x00D9, + Uacute: 0x00DA, + Ucirc: 0x00DB, + Uuml: 0x00DC, + Yacute: 0x00DD, + THORN: 0x00DE, + szlig: 0x00DF, + agrave: 0x00E0, + aacute: 0x00E1, + acirc: 0x00E2, + atilde: 0x00E3, + auml: 0x00E4, + aring: 0x00E5, + aelig: 0x00E6, + ccedil: 0x00E7, + egrave: 0x00E8, + eacute: 0x00E9, + ecirc: 0x00EA, + euml: 0x00EB, + igrave: 0x00EC, + iacute: 0x00ED, + icirc: 0x00EE, + iuml: 0x00EF, + eth: 0x00F0, + ntilde: 0x00F1, + ograve: 0x00F2, + oacute: 0x00F3, + ocirc: 0x00F4, + otilde: 0x00F5, + ouml: 0x00F6, + divide: 0x00F7, + oslash: 0x00F8, + ugrave: 0x00F9, + uacute: 0x00FA, + ucirc: 0x00FB, + uuml: 0x00FC, + yacute: 0x00FD, + thorn: 0x00FE, + yuml: 0x00FF, + OElig: 0x0152, + oelig: 0x0153, + Scaron: 0x0160, + scaron: 0x0161, + Yuml: 0x0178, + fnof: 0x0192, + circ: 0x02C6, + tilde: 0x02DC, + Alpha: 0x0391, + Beta: 0x0392, + Gamma: 0x0393, + Delta: 0x0394, + Epsilon: 0x0395, + Zeta: 0x0396, + Eta: 0x0397, + Theta: 0x0398, + Iota: 0x0399, + Kappa: 0x039A, + Lambda: 0x039B, + Mu: 0x039C, + Nu: 0x039D, + Xi: 0x039E, + Omicron: 0x039F, + Pi: 0x03A0, + Rho: 0x03A1, + Sigma: 0x03A3, + Tau: 0x03A4, + Upsilon: 0x03A5, + Phi: 0x03A6, + Chi: 0x03A7, + Psi: 0x03A8, + Omega: 0x03A9, + alpha: 0x03B1, + beta: 0x03B2, + gamma: 0x03B3, + delta: 0x03B4, + epsilon: 0x03B5, + zeta: 0x03B6, + eta: 0x03B7, + theta: 0x03B8, + iota: 0x03B9, + kappa: 0x03BA, + lambda: 0x03BB, + mu: 0x03BC, + nu: 0x03BD, + xi: 0x03BE, + omicron: 0x03BF, + pi: 0x03C0, + rho: 0x03C1, + sigmaf: 0x03C2, + sigma: 0x03C3, + tau: 0x03C4, + upsilon: 0x03C5, + phi: 0x03C6, + chi: 0x03C7, + psi: 0x03C8, + omega: 0x03C9, + thetasym: 0x03D1, + upsih: 0x03D2, + piv: 0x03D6, + ensp: 0x2002, + emsp: 0x2003, + thinsp: 0x2009, + zwnj: 0x200C, + zwj: 0x200D, + lrm: 0x200E, + rlm: 0x200F, + ndash: 0x2013, + mdash: 0x2014, + lsquo: 0x2018, + rsquo: 0x2019, + sbquo: 0x201A, + ldquo: 0x201C, + rdquo: 0x201D, + bdquo: 0x201E, + dagger: 0x2020, + Dagger: 0x2021, + bull: 0x2022, + hellip: 0x2026, + permil: 0x2030, + prime: 0x2032, + Prime: 0x2033, + lsaquo: 0x2039, + rsaquo: 0x203A, + oline: 0x203E, + frasl: 0x2044, + euro: 0x20AC, + image: 0x2111, + weierp: 0x2118, + real: 0x211C, + trade: 0x2122, + alefsym: 0x2135, + larr: 0x2190, + uarr: 0x2191, + rarr: 0x2192, + darr: 0x2193, + harr: 0x2194, + crarr: 0x21B5, + lArr: 0x21D0, + uArr: 0x21D1, + rArr: 0x21D2, + dArr: 0x21D3, + hArr: 0x21D4, + forall: 0x2200, + part: 0x2202, + exist: 0x2203, + empty: 0x2205, + nabla: 0x2207, + isin: 0x2208, + notin: 0x2209, + ni: 0x220B, + prod: 0x220F, + sum: 0x2211, + minus: 0x2212, + lowast: 0x2217, + radic: 0x221A, + prop: 0x221D, + infin: 0x221E, + ang: 0x2220, + and: 0x2227, + or: 0x2228, + cap: 0x2229, + cup: 0x222A, + int: 0x222B, + there4: 0x2234, + sim: 0x223C, + cong: 0x2245, + asymp: 0x2248, + ne: 0x2260, + equiv: 0x2261, + le: 0x2264, + ge: 0x2265, + sub: 0x2282, + sup: 0x2283, + nsub: 0x2284, + sube: 0x2286, + supe: 0x2287, + oplus: 0x2295, + otimes: 0x2297, + perp: 0x22A5, + sdot: 0x22C5, + lceil: 0x2308, + rceil: 0x2309, + lfloor: 0x230A, + rfloor: 0x230B, + lang: 0x2329, + rang: 0x232A, + loz: 0x25CA, + spades: 0x2660, + clubs: 0x2663, + hearts: 0x2665, + diams: 0x2666 + }); +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2016(context) { + var hoistVariableDeclaration = context.hoistVariableDeclaration; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 128) === 0) { + return node; + } + switch (node.kind) { + case 209: + return visitBinaryExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitBinaryExpression(node) { + switch (node.operatorToken.kind) { + case 66: + return visitExponentiationAssignmentExpression(node); + case 42: + return visitExponentiationExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitExponentiationAssignmentExpression(node) { + var target; + var value; + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = ts.visitNode(node.right, visitor, ts.isExpression); + if (ts.isElementAccessExpression(left)) { + var expressionTemp = ts.createTempVariable(hoistVariableDeclaration); + var argumentExpressionTemp = ts.createTempVariable(hoistVariableDeclaration); + target = ts.setTextRange(ts.createElementAccess(ts.setTextRange(ts.createAssignment(expressionTemp, left.expression), left.expression), ts.setTextRange(ts.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)), left); + value = ts.setTextRange(ts.createElementAccess(expressionTemp, argumentExpressionTemp), left); + } + else if (ts.isPropertyAccessExpression(left)) { + var expressionTemp = ts.createTempVariable(hoistVariableDeclaration); + target = ts.setTextRange(ts.createPropertyAccess(ts.setTextRange(ts.createAssignment(expressionTemp, left.expression), left.expression), left.name), left); + value = ts.setTextRange(ts.createPropertyAccess(expressionTemp, left.name), left); + } + else { + target = left; + value = left; + } + return ts.setTextRange(ts.createAssignment(target, ts.createMathPow(value, right, node)), node); + } + function visitExponentiationExpression(node) { + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = ts.visitNode(node.right, visitor, ts.isExpression); + return ts.createMathPow(left, right, node); + } + } + ts.transformES2016 = transformES2016; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES2015(context) { + var startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + var currentSourceFile; + var currentText; + var hierarchyFacts; + var taggedTemplateStringDeclarations; + function recordTaggedTemplateString(temp) { + taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, ts.createVariableDeclaration(temp)); + } + var convertedLoopState; + var enabledSubstitutions; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + currentText = node.text; + var visited = visitSourceFile(node); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + currentSourceFile = undefined; + currentText = undefined; + taggedTemplateStringDeclarations = undefined; + hierarchyFacts = 0; + return visited; + } + function enterSubtree(excludeFacts, includeFacts) { + var ancestorFacts = hierarchyFacts; + hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 16383; + return ancestorFacts; + } + function exitSubtree(ancestorFacts, excludeFacts, includeFacts) { + hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & -16384 | ancestorFacts; + } + function isReturnVoidStatementInConstructorWithCapturedSuper(node) { + return (hierarchyFacts & 8192) !== 0 + && node.kind === 235 + && !node.expression; + } + function shouldVisitNode(node) { + return (node.transformFlags & 256) !== 0 + || convertedLoopState !== undefined + || (hierarchyFacts & 8192 && (ts.isStatement(node) || (node.kind === 223))) + || (ts.isIterationStatement(node, false) && shouldConvertIterationStatement(node)) + || (ts.getEmitFlags(node) & 33554432) !== 0; + } + function visitor(node) { + if (shouldVisitNode(node)) { + return visitJavaScript(node); + } + else { + return node; + } + } + function callExpressionVisitor(node) { + if (node.kind === 102) { + return visitSuperKeyword(true); + } + return visitor(node); + } + function visitJavaScript(node) { + switch (node.kind) { + case 120: + return undefined; + case 245: + return visitClassDeclaration(node); + case 214: + return visitClassExpression(node); + case 156: + return visitParameter(node); + case 244: + return visitFunctionDeclaration(node); + case 202: + return visitArrowFunction(node); + case 201: + return visitFunctionExpression(node); + case 242: + return visitVariableDeclaration(node); + case 75: + return visitIdentifier(node); + case 243: + return visitVariableDeclarationList(node); + case 237: + return visitSwitchStatement(node); + case 251: + return visitCaseBlock(node); + case 223: + return visitBlock(node, false); + case 234: + case 233: + return visitBreakOrContinueStatement(node); + case 238: + return visitLabeledStatement(node); + case 228: + case 229: + return visitDoOrWhileStatement(node, undefined); + case 230: + return visitForStatement(node, undefined); + case 231: + return visitForInStatement(node, undefined); + case 232: + return visitForOfStatement(node, undefined); + case 226: + return visitExpressionStatement(node); + case 193: + return visitObjectLiteralExpression(node); + case 280: + return visitCatchClause(node); + case 282: + return visitShorthandPropertyAssignment(node); + case 154: + return visitComputedPropertyName(node); + case 192: + return visitArrayLiteralExpression(node); + case 196: + return visitCallExpression(node); + case 197: + return visitNewExpression(node); + case 200: + return visitParenthesizedExpression(node, true); + case 209: + return visitBinaryExpression(node, true); + case 14: + case 15: + case 16: + case 17: + return visitTemplateLiteral(node); + case 10: + return visitStringLiteral(node); + case 8: + return visitNumericLiteral(node); + case 198: + return visitTaggedTemplateExpression(node); + case 211: + return visitTemplateExpression(node); + case 212: + return visitYieldExpression(node); + case 213: + return visitSpreadElement(node); + case 102: + return visitSuperKeyword(false); + case 104: + return visitThisKeyword(node); + case 219: + return visitMetaProperty(node); + case 161: + return visitMethodDeclaration(node); + case 163: + case 164: + return visitAccessorDeclaration(node); + case 225: + return visitVariableStatement(node); + case 235: + return visitReturnStatement(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitSourceFile(node) { + var ancestorFacts = enterSubtree(8064, 64); + var prologue = []; + var statements = []; + startLexicalEnvironment(); + var statementOffset = ts.addStandardPrologue(prologue, node.statements, false); + statementOffset = ts.addCustomPrologue(prologue, node.statements, statementOffset, visitor); + ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset)); + if (taggedTemplateStringDeclarations) { + statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(taggedTemplateStringDeclarations))); + } + ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureThisForNodeIfNeeded(prologue, node); + exitSubtree(ancestorFacts, 0, 0); + return ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(ts.concatenate(prologue, statements)), node.statements)); + } + function visitSwitchStatement(node) { + if (convertedLoopState !== undefined) { + var savedAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps; + convertedLoopState.allowedNonLabeledJumps |= 2; + var result = ts.visitEachChild(node, visitor, context); + convertedLoopState.allowedNonLabeledJumps = savedAllowedNonLabeledJumps; + return result; + } + return ts.visitEachChild(node, visitor, context); + } + function visitCaseBlock(node) { + var ancestorFacts = enterSubtree(7104, 0); + var updated = ts.visitEachChild(node, visitor, context); + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function returnCapturedThis(node) { + return ts.setOriginalNode(ts.createReturn(ts.createFileLevelUniqueName("_this")), node); + } + function visitReturnStatement(node) { + if (convertedLoopState) { + convertedLoopState.nonLocalJumps |= 8; + if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) { + node = returnCapturedThis(node); + } + return ts.createReturn(ts.createObjectLiteral([ + ts.createPropertyAssignment(ts.createIdentifier("value"), node.expression + ? ts.visitNode(node.expression, visitor, ts.isExpression) + : ts.createVoidZero()) + ])); + } + else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) { + return returnCapturedThis(node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitThisKeyword(node) { + if (hierarchyFacts & 2) { + hierarchyFacts |= 32768; + } + if (convertedLoopState) { + if (hierarchyFacts & 2) { + convertedLoopState.containsLexicalThis = true; + return node; + } + return convertedLoopState.thisName || (convertedLoopState.thisName = ts.createUniqueName("this")); + } + return node; + } + function visitIdentifier(node) { + if (!convertedLoopState) { + return node; + } + if (ts.isGeneratedIdentifier(node)) { + return node; + } + if (node.escapedText !== "arguments" || !resolver.isArgumentsLocalBinding(node)) { + return node; + } + return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = ts.createUniqueName("arguments")); + } + function visitBreakOrContinueStatement(node) { + if (convertedLoopState) { + var jump = node.kind === 234 ? 2 : 4; + var canUseBreakOrContinue = (node.label && convertedLoopState.labels && convertedLoopState.labels.get(ts.idText(node.label))) || + (!node.label && (convertedLoopState.allowedNonLabeledJumps & jump)); + if (!canUseBreakOrContinue) { + var labelMarker = void 0; + var label = node.label; + if (!label) { + if (node.kind === 234) { + convertedLoopState.nonLocalJumps |= 2; + labelMarker = "break"; + } + else { + convertedLoopState.nonLocalJumps |= 4; + labelMarker = "continue"; + } + } + else { + if (node.kind === 234) { + labelMarker = "break-" + label.escapedText; + setLabeledJump(convertedLoopState, true, ts.idText(label), labelMarker); + } + else { + labelMarker = "continue-" + label.escapedText; + setLabeledJump(convertedLoopState, false, ts.idText(label), labelMarker); + } + } + var returnExpression = ts.createLiteral(labelMarker); + if (convertedLoopState.loopOutParameters.length) { + var outParams = convertedLoopState.loopOutParameters; + var expr = void 0; + for (var i = 0; i < outParams.length; i++) { + var copyExpr = copyOutParameter(outParams[i], 1); + if (i === 0) { + expr = copyExpr; + } + else { + expr = ts.createBinary(expr, 27, copyExpr); + } + } + returnExpression = ts.createBinary(expr, 27, returnExpression); + } + return ts.createReturn(returnExpression); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitClassDeclaration(node) { + var variable = ts.createVariableDeclaration(ts.getLocalName(node, true), undefined, transformClassLikeDeclarationToExpression(node)); + ts.setOriginalNode(variable, node); + var statements = []; + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([variable])); + ts.setOriginalNode(statement, node); + ts.setTextRange(statement, node); + ts.startOnNewLine(statement); + statements.push(statement); + if (ts.hasModifier(node, 1)) { + var exportStatement = ts.hasModifier(node, 512) + ? ts.createExportDefault(ts.getLocalName(node)) + : ts.createExternalModuleExport(ts.getLocalName(node)); + ts.setOriginalNode(exportStatement, statement); + statements.push(exportStatement); + } + var emitFlags = ts.getEmitFlags(node); + if ((emitFlags & 4194304) === 0) { + statements.push(ts.createEndOfDeclarationMarker(node)); + ts.setEmitFlags(statement, emitFlags | 4194304); + } + return ts.singleOrMany(statements); + } + function visitClassExpression(node) { + return transformClassLikeDeclarationToExpression(node); + } + function transformClassLikeDeclarationToExpression(node) { + if (node.name) { + enableSubstitutionsForBlockScopedBindings(); + } + var extendsClauseElement = ts.getClassExtendsHeritageElement(node); + var classFunction = ts.createFunctionExpression(undefined, undefined, undefined, undefined, extendsClauseElement ? [ts.createParameter(undefined, undefined, undefined, ts.createFileLevelUniqueName("_super"))] : [], undefined, transformClassBody(node, extendsClauseElement)); + ts.setEmitFlags(classFunction, (ts.getEmitFlags(node) & 65536) | 524288); + var inner = ts.createPartiallyEmittedExpression(classFunction); + inner.end = node.end; + ts.setEmitFlags(inner, 1536); + var outer = ts.createPartiallyEmittedExpression(inner); + outer.end = ts.skipTrivia(currentText, node.pos); + ts.setEmitFlags(outer, 1536); + var result = ts.createParen(ts.createCall(outer, undefined, extendsClauseElement + ? [ts.visitNode(extendsClauseElement.expression, visitor, ts.isExpression)] + : [])); + ts.addSyntheticLeadingComment(result, 3, "* @class "); + return result; + } + function transformClassBody(node, extendsClauseElement) { + var statements = []; + startLexicalEnvironment(); + addExtendsHelperIfNeeded(statements, node, extendsClauseElement); + addConstructor(statements, node, extendsClauseElement); + addClassMembers(statements, node); + var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentText, node.members.end), 19); + var localName = ts.getInternalName(node); + var outer = ts.createPartiallyEmittedExpression(localName); + outer.end = closingBraceLocation.end; + ts.setEmitFlags(outer, 1536); + var statement = ts.createReturn(outer); + statement.pos = closingBraceLocation.pos; + ts.setEmitFlags(statement, 1536 | 384); + statements.push(statement); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), node.members), true); + ts.setEmitFlags(block, 1536); + return block; + } + function addExtendsHelperIfNeeded(statements, node, extendsClauseElement) { + if (extendsClauseElement) { + statements.push(ts.setTextRange(ts.createExpressionStatement(createExtendsHelper(context, ts.getInternalName(node))), extendsClauseElement)); + } + } + function addConstructor(statements, node, extendsClauseElement) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(16278, 73); + var constructor = ts.getFirstConstructorWithBody(node); + var hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== undefined); + var constructorFunction = ts.createFunctionDeclaration(undefined, undefined, undefined, ts.getInternalName(node), undefined, transformConstructorParameters(constructor, hasSynthesizedSuper), undefined, transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)); + ts.setTextRange(constructorFunction, constructor || node); + if (extendsClauseElement) { + ts.setEmitFlags(constructorFunction, 8); + } + statements.push(constructorFunction); + exitSubtree(ancestorFacts, 49152, 0); + convertedLoopState = savedConvertedLoopState; + } + function transformConstructorParameters(constructor, hasSynthesizedSuper) { + return ts.visitParameterList(constructor && !hasSynthesizedSuper ? constructor.parameters : undefined, visitor, context) + || []; + } + function createDefaultConstructorBody(node, isDerivedClass) { + var statements = []; + resumeLexicalEnvironment(); + ts.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + if (isDerivedClass) { + statements.push(ts.createReturn(createDefaultSuperCallOrThis())); + } + var statementsArray = ts.createNodeArray(statements); + ts.setTextRange(statementsArray, node.members); + var block = ts.createBlock(statementsArray, true); + ts.setTextRange(block, node); + ts.setEmitFlags(block, 1536); + return block; + } + function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) { + var isDerivedClass = !!extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100; + if (!constructor) + return createDefaultConstructorBody(node, isDerivedClass); + var prologue = []; + var statements = []; + resumeLexicalEnvironment(); + var statementOffset = 0; + if (!hasSynthesizedSuper) + statementOffset = ts.addStandardPrologue(prologue, constructor.body.statements, false); + addDefaultValueAssignmentsIfNeeded(statements, constructor); + addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper); + if (!hasSynthesizedSuper) + statementOffset = ts.addCustomPrologue(statements, constructor.body.statements, statementOffset, visitor); + var superCallExpression; + if (hasSynthesizedSuper) { + superCallExpression = createDefaultSuperCallOrThis(); + } + else if (isDerivedClass && statementOffset < constructor.body.statements.length) { + var firstStatement = constructor.body.statements[statementOffset]; + if (ts.isExpressionStatement(firstStatement) && ts.isSuperCall(firstStatement.expression)) { + superCallExpression = visitImmediateSuperCallInBody(firstStatement.expression); + } + } + if (superCallExpression) { + hierarchyFacts |= 8192; + statementOffset++; + } + ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, statementOffset)); + ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureNewTargetIfNeeded(prologue, constructor, false); + if (isDerivedClass) { + if (superCallExpression && statementOffset === constructor.body.statements.length && !(constructor.body.transformFlags & 4096)) { + var superCall = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression); + var returnStatement = ts.createReturn(superCallExpression); + ts.setCommentRange(returnStatement, ts.getCommentRange(superCall)); + ts.setEmitFlags(superCall, 1536); + statements.push(returnStatement); + } + else { + insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis()); + if (!isSufficientlyCoveredByReturnStatements(constructor.body)) { + statements.push(ts.createReturn(ts.createFileLevelUniqueName("_this"))); + } + } + } + else { + insertCaptureThisForNodeIfNeeded(prologue, constructor); + } + var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(ts.concatenate(prologue, statements)), constructor.body.statements), true); + ts.setTextRange(block, constructor.body); + return block; + } + function isSufficientlyCoveredByReturnStatements(statement) { + if (statement.kind === 235) { + return true; + } + else if (statement.kind === 227) { + var ifStatement = statement; + if (ifStatement.elseStatement) { + return isSufficientlyCoveredByReturnStatements(ifStatement.thenStatement) && + isSufficientlyCoveredByReturnStatements(ifStatement.elseStatement); + } + } + else if (statement.kind === 223) { + var lastStatement = ts.lastOrUndefined(statement.statements); + if (lastStatement && isSufficientlyCoveredByReturnStatements(lastStatement)) { + return true; + } + } + return false; + } + function createActualThis() { + return ts.setEmitFlags(ts.createThis(), 4); + } + function createDefaultSuperCallOrThis() { + return ts.createLogicalOr(ts.createLogicalAnd(ts.createStrictInequality(ts.createFileLevelUniqueName("_super"), ts.createNull()), ts.createFunctionApply(ts.createFileLevelUniqueName("_super"), createActualThis(), ts.createIdentifier("arguments"))), createActualThis()); + } + function visitParameter(node) { + if (node.dotDotDotToken) { + return undefined; + } + else if (ts.isBindingPattern(node.name)) { + return ts.setOriginalNode(ts.setTextRange(ts.createParameter(undefined, undefined, undefined, ts.getGeneratedNameForNode(node), undefined, undefined, undefined), node), node); + } + else if (node.initializer) { + return ts.setOriginalNode(ts.setTextRange(ts.createParameter(undefined, undefined, undefined, node.name, undefined, undefined, undefined), node), node); + } + else { + return node; + } + } + function hasDefaultValueOrBindingPattern(node) { + return node.initializer !== undefined + || ts.isBindingPattern(node.name); + } + function addDefaultValueAssignmentsIfNeeded(statements, node) { + if (!ts.some(node.parameters, hasDefaultValueOrBindingPattern)) { + return false; + } + var added = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + var name = parameter.name, initializer = parameter.initializer, dotDotDotToken = parameter.dotDotDotToken; + if (dotDotDotToken) { + continue; + } + if (ts.isBindingPattern(name)) { + added = insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) || added; + } + else if (initializer) { + insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer); + added = true; + } + } + return added; + } + function insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) { + if (name.elements.length > 0) { + ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, ts.getGeneratedNameForNode(parameter)))), 1048576)); + return true; + } + else if (initializer) { + ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(ts.createExpressionStatement(ts.createAssignment(ts.getGeneratedNameForNode(parameter), ts.visitNode(initializer, visitor, ts.isExpression))), 1048576)); + return true; + } + return false; + } + function insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer) { + initializer = ts.visitNode(initializer, visitor, ts.isExpression); + var statement = ts.createIf(ts.createTypeCheck(ts.getSynthesizedClone(name), "undefined"), ts.setEmitFlags(ts.setTextRange(ts.createBlock([ + ts.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(ts.createAssignment(ts.setEmitFlags(ts.getMutableClone(name), 48), ts.setEmitFlags(initializer, 48 | ts.getEmitFlags(initializer) | 1536)), parameter), 1536)) + ]), parameter), 1 | 32 | 384 | 1536)); + ts.startOnNewLine(statement); + ts.setTextRange(statement, parameter); + ts.setEmitFlags(statement, 384 | 32 | 1048576 | 1536); + ts.insertStatementAfterCustomPrologue(statements, statement); + } + function shouldAddRestParameter(node, inConstructorWithSynthesizedSuper) { + return !!(node && node.dotDotDotToken && !inConstructorWithSynthesizedSuper); + } + function addRestParameterIfNeeded(statements, node, inConstructorWithSynthesizedSuper) { + var prologueStatements = []; + var parameter = ts.lastOrUndefined(node.parameters); + if (!shouldAddRestParameter(parameter, inConstructorWithSynthesizedSuper)) { + return false; + } + var declarationName = parameter.name.kind === 75 ? ts.getMutableClone(parameter.name) : ts.createTempVariable(undefined); + ts.setEmitFlags(declarationName, 48); + var expressionName = parameter.name.kind === 75 ? ts.getSynthesizedClone(parameter.name) : declarationName; + var restIndex = node.parameters.length - 1; + var temp = ts.createLoopVariable(); + prologueStatements.push(ts.setEmitFlags(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(declarationName, undefined, ts.createArrayLiteral([])) + ])), parameter), 1048576)); + var forStatement = ts.createFor(ts.setTextRange(ts.createVariableDeclarationList([ + ts.createVariableDeclaration(temp, undefined, ts.createLiteral(restIndex)) + ]), parameter), ts.setTextRange(ts.createLessThan(temp, ts.createPropertyAccess(ts.createIdentifier("arguments"), "length")), parameter), ts.setTextRange(ts.createPostfixIncrement(temp), parameter), ts.createBlock([ + ts.startOnNewLine(ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(ts.createElementAccess(expressionName, restIndex === 0 + ? temp + : ts.createSubtract(temp, ts.createLiteral(restIndex))), ts.createElementAccess(ts.createIdentifier("arguments"), temp))), parameter)) + ])); + ts.setEmitFlags(forStatement, 1048576); + ts.startOnNewLine(forStatement); + prologueStatements.push(forStatement); + if (parameter.name.kind !== 75) { + prologueStatements.push(ts.setEmitFlags(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, expressionName))), parameter), 1048576)); + } + ts.insertStatementsAfterCustomPrologue(statements, prologueStatements); + return true; + } + function insertCaptureThisForNodeIfNeeded(statements, node) { + if (hierarchyFacts & 32768 && node.kind !== 202) { + insertCaptureThisForNode(statements, node, ts.createThis()); + return true; + } + return false; + } + function insertCaptureThisForNode(statements, node, initializer) { + enableSubstitutionsForCapturedThis(); + var captureThisStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.createFileLevelUniqueName("_this"), undefined, initializer) + ])); + ts.setEmitFlags(captureThisStatement, 1536 | 1048576); + ts.setSourceMapRange(captureThisStatement, node); + ts.insertStatementAfterCustomPrologue(statements, captureThisStatement); + } + function insertCaptureNewTargetIfNeeded(statements, node, copyOnWrite) { + if (hierarchyFacts & 16384) { + var newTarget = void 0; + switch (node.kind) { + case 202: + return statements; + case 161: + case 163: + case 164: + newTarget = ts.createVoidZero(); + break; + case 162: + newTarget = ts.createPropertyAccess(ts.setEmitFlags(ts.createThis(), 4), "constructor"); + break; + case 244: + case 201: + newTarget = ts.createConditional(ts.createLogicalAnd(ts.setEmitFlags(ts.createThis(), 4), ts.createBinary(ts.setEmitFlags(ts.createThis(), 4), 98, ts.getLocalName(node))), ts.createPropertyAccess(ts.setEmitFlags(ts.createThis(), 4), "constructor"), ts.createVoidZero()); + break; + default: + return ts.Debug.failBadSyntaxKind(node); + } + var captureNewTargetStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.createFileLevelUniqueName("_newTarget"), undefined, newTarget) + ])); + ts.setEmitFlags(captureNewTargetStatement, 1536 | 1048576); + if (copyOnWrite) { + statements = statements.slice(); + } + ts.insertStatementAfterCustomPrologue(statements, captureNewTargetStatement); + } + return statements; + } + function addClassMembers(statements, node) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + switch (member.kind) { + case 222: + statements.push(transformSemicolonClassElementToStatement(member)); + break; + case 161: + statements.push(transformClassMethodDeclarationToStatement(getClassMemberPrefix(node, member), member, node)); + break; + case 163: + case 164: + var accessors = ts.getAllAccessorDeclarations(node.members, member); + if (member === accessors.firstAccessor) { + statements.push(transformAccessorsToStatement(getClassMemberPrefix(node, member), accessors, node)); + } + break; + case 162: + break; + default: + ts.Debug.failBadSyntaxKind(member, currentSourceFile && currentSourceFile.fileName); + break; + } + } + } + function transformSemicolonClassElementToStatement(member) { + return ts.setTextRange(ts.createEmptyStatement(), member); + } + function transformClassMethodDeclarationToStatement(receiver, member, container) { + var commentRange = ts.getCommentRange(member); + var sourceMapRange = ts.getSourceMapRange(member); + var memberFunction = transformFunctionLikeToExpression(member, member, undefined, container); + var propertyName = ts.visitNode(member.name, visitor, ts.isPropertyName); + var e; + if (!ts.isPrivateIdentifier(propertyName) && context.getCompilerOptions().useDefineForClassFields) { + var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression + : ts.isIdentifier(propertyName) ? ts.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText)) + : propertyName; + e = ts.createObjectDefinePropertyCall(receiver, name, ts.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true })); + } + else { + var memberName = ts.createMemberAccessForPropertyName(receiver, propertyName, member.name); + e = ts.createAssignment(memberName, memberFunction); + } + ts.setEmitFlags(memberFunction, 1536); + ts.setSourceMapRange(memberFunction, sourceMapRange); + var statement = ts.setTextRange(ts.createExpressionStatement(e), member); + ts.setOriginalNode(statement, member); + ts.setCommentRange(statement, commentRange); + ts.setEmitFlags(statement, 48); + return statement; + } + function transformAccessorsToStatement(receiver, accessors, container) { + var statement = ts.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, false)); + ts.setEmitFlags(statement, 1536); + ts.setSourceMapRange(statement, ts.getSourceMapRange(accessors.firstAccessor)); + return statement; + } + function transformAccessorsToExpression(receiver, _a, container, startsOnNewLine) { + var firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + var target = ts.getMutableClone(receiver); + ts.setEmitFlags(target, 1536 | 32); + ts.setSourceMapRange(target, firstAccessor.name); + var visitedAccessorName = ts.visitNode(firstAccessor.name, visitor, ts.isPropertyName); + if (ts.isPrivateIdentifier(visitedAccessorName)) { + return ts.Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015."); + } + var propertyName = ts.createExpressionForPropertyName(visitedAccessorName); + ts.setEmitFlags(propertyName, 1536 | 16); + ts.setSourceMapRange(propertyName, firstAccessor.name); + var properties = []; + if (getAccessor) { + var getterFunction = transformFunctionLikeToExpression(getAccessor, undefined, undefined, container); + ts.setSourceMapRange(getterFunction, ts.getSourceMapRange(getAccessor)); + ts.setEmitFlags(getterFunction, 512); + var getter = ts.createPropertyAssignment("get", getterFunction); + ts.setCommentRange(getter, ts.getCommentRange(getAccessor)); + properties.push(getter); + } + if (setAccessor) { + var setterFunction = transformFunctionLikeToExpression(setAccessor, undefined, undefined, container); + ts.setSourceMapRange(setterFunction, ts.getSourceMapRange(setAccessor)); + ts.setEmitFlags(setterFunction, 512); + var setter = ts.createPropertyAssignment("set", setterFunction); + ts.setCommentRange(setter, ts.getCommentRange(setAccessor)); + properties.push(setter); + } + properties.push(ts.createPropertyAssignment("enumerable", ts.createTrue()), ts.createPropertyAssignment("configurable", ts.createTrue())); + var call = ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [ + target, + propertyName, + ts.createObjectLiteral(properties, true) + ]); + if (startsOnNewLine) { + ts.startOnNewLine(call); + } + return call; + } + function visitArrowFunction(node) { + if (node.transformFlags & 4096) { + hierarchyFacts |= 32768; + } + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(15232, 66); + var func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node)); + ts.setTextRange(func, node); + ts.setOriginalNode(func, node); + ts.setEmitFlags(func, 8); + if (hierarchyFacts & 32768) { + enableSubstitutionsForCapturedThis(); + } + exitSubtree(ancestorFacts, 0, 0); + convertedLoopState = savedConvertedLoopState; + return func; + } + function visitFunctionExpression(node) { + var ancestorFacts = ts.getEmitFlags(node) & 262144 + ? enterSubtree(16278, 69) + : enterSubtree(16286, 65); + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + var name = hierarchyFacts & 16384 + ? ts.getLocalName(node) + : node.name; + exitSubtree(ancestorFacts, 49152, 0); + convertedLoopState = savedConvertedLoopState; + return ts.updateFunctionExpression(node, undefined, node.asteriskToken, name, undefined, parameters, undefined, body); + } + function visitFunctionDeclaration(node) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(16286, 65); + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + var name = hierarchyFacts & 16384 + ? ts.getLocalName(node) + : node.name; + exitSubtree(ancestorFacts, 49152, 0); + convertedLoopState = savedConvertedLoopState; + return ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, name, undefined, parameters, undefined, body); + } + function transformFunctionLikeToExpression(node, location, name, container) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = container && ts.isClassLike(container) && !ts.hasModifier(node, 32) + ? enterSubtree(16286, 65 | 8) + : enterSubtree(16286, 65); + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + if (hierarchyFacts & 16384 && !name && (node.kind === 244 || node.kind === 201)) { + name = ts.getGeneratedNameForNode(node); + } + exitSubtree(ancestorFacts, 49152, 0); + convertedLoopState = savedConvertedLoopState; + return ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(undefined, node.asteriskToken, name, undefined, parameters, undefined, body), location), node); + } + function transformFunctionBody(node) { + var multiLine = false; + var singleLine = false; + var statementsLocation; + var closeBraceLocation; + var prologue = []; + var statements = []; + var body = node.body; + var statementOffset; + resumeLexicalEnvironment(); + if (ts.isBlock(body)) { + statementOffset = ts.addStandardPrologue(prologue, body.statements, false); + } + multiLine = addDefaultValueAssignmentsIfNeeded(statements, node) || multiLine; + multiLine = addRestParameterIfNeeded(statements, node, false) || multiLine; + if (ts.isBlock(body)) { + statementOffset = ts.addCustomPrologue(statements, body.statements, statementOffset, visitor); + statementsLocation = body.statements; + ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, statementOffset)); + if (!multiLine && body.multiLine) { + multiLine = true; + } + } + else { + ts.Debug.assert(node.kind === 202); + statementsLocation = ts.moveRangeEnd(body, -1); + var equalsGreaterThanToken = node.equalsGreaterThanToken; + if (!ts.nodeIsSynthesized(equalsGreaterThanToken) && !ts.nodeIsSynthesized(body)) { + if (ts.rangeEndIsOnSameLineAsRangeStart(equalsGreaterThanToken, body, currentSourceFile)) { + singleLine = true; + } + else { + multiLine = true; + } + } + var expression = ts.visitNode(body, visitor, ts.isExpression); + var returnStatement = ts.createReturn(expression); + ts.setTextRange(returnStatement, body); + ts.moveSyntheticComments(returnStatement, body); + ts.setEmitFlags(returnStatement, 384 | 32 | 1024); + statements.push(returnStatement); + closeBraceLocation = body; + } + ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureNewTargetIfNeeded(prologue, node, false); + insertCaptureThisForNodeIfNeeded(prologue, node); + if (ts.some(prologue)) { + multiLine = true; + } + statements.unshift.apply(statements, prologue); + if (ts.isBlock(body) && ts.arrayIsEqualTo(statements, body.statements)) { + return body; + } + var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), multiLine); + ts.setTextRange(block, node.body); + if (!multiLine && singleLine) { + ts.setEmitFlags(block, 1); + } + if (closeBraceLocation) { + ts.setTokenSourceMapRange(block, 19, closeBraceLocation); + } + ts.setOriginalNode(block, node.body); + return block; + } + function visitBlock(node, isFunctionBody) { + if (isFunctionBody) { + return ts.visitEachChild(node, visitor, context); + } + var ancestorFacts = hierarchyFacts & 256 + ? enterSubtree(7104, 512) + : enterSubtree(6976, 128); + var updated = ts.visitEachChild(node, visitor, context); + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function visitExpressionStatement(node) { + switch (node.expression.kind) { + case 200: + return ts.updateExpressionStatement(node, visitParenthesizedExpression(node.expression, false)); + case 209: + return ts.updateExpressionStatement(node, visitBinaryExpression(node.expression, false)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitParenthesizedExpression(node, needsDestructuringValue) { + if (!needsDestructuringValue) { + switch (node.expression.kind) { + case 200: + return ts.updateParen(node, visitParenthesizedExpression(node.expression, false)); + case 209: + return ts.updateParen(node, visitBinaryExpression(node.expression, false)); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitBinaryExpression(node, needsDestructuringValue) { + if (ts.isDestructuringAssignment(node)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0, needsDestructuringValue); + } + return ts.visitEachChild(node, visitor, context); + } + function visitVariableStatement(node) { + var ancestorFacts = enterSubtree(0, ts.hasModifier(node, 1) ? 32 : 0); + var updated; + if (convertedLoopState && (node.declarationList.flags & 3) === 0) { + var assignments = void 0; + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + hoistVariableDeclarationDeclaredInConvertedLoop(convertedLoopState, decl); + if (decl.initializer) { + var assignment = void 0; + if (ts.isBindingPattern(decl.name)) { + assignment = ts.flattenDestructuringAssignment(decl, visitor, context, 0); + } + else { + assignment = ts.createBinary(decl.name, 62, ts.visitNode(decl.initializer, visitor, ts.isExpression)); + ts.setTextRange(assignment, decl); + } + assignments = ts.append(assignments, assignment); + } + } + if (assignments) { + updated = ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(assignments)), node); + } + else { + updated = undefined; + } + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function visitVariableDeclarationList(node) { + if (node.flags & 3 || node.transformFlags & 131072) { + if (node.flags & 3) { + enableSubstitutionsForBlockScopedBindings(); + } + var declarations = ts.flatMap(node.declarations, node.flags & 1 + ? visitVariableDeclarationInLetDeclarationList + : visitVariableDeclaration); + var declarationList = ts.createVariableDeclarationList(declarations); + ts.setOriginalNode(declarationList, node); + ts.setTextRange(declarationList, node); + ts.setCommentRange(declarationList, node); + if (node.transformFlags & 131072 + && (ts.isBindingPattern(node.declarations[0].name) || ts.isBindingPattern(ts.last(node.declarations).name))) { + ts.setSourceMapRange(declarationList, getRangeUnion(declarations)); + } + return declarationList; + } + return ts.visitEachChild(node, visitor, context); + } + function getRangeUnion(declarations) { + var pos = -1, end = -1; + for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) { + var node = declarations_10[_i]; + pos = pos === -1 ? node.pos : node.pos === -1 ? pos : Math.min(pos, node.pos); + end = Math.max(end, node.end); + } + return ts.createRange(pos, end); + } + function shouldEmitExplicitInitializerForLetDeclaration(node) { + var flags = resolver.getNodeCheckFlags(node); + var isCapturedInFunction = flags & 262144; + var isDeclaredInLoop = flags & 524288; + var emittedAsTopLevel = (hierarchyFacts & 64) !== 0 + || (isCapturedInFunction + && isDeclaredInLoop + && (hierarchyFacts & 512) !== 0); + var emitExplicitInitializer = !emittedAsTopLevel + && (hierarchyFacts & 4096) === 0 + && (!resolver.isDeclarationWithCollidingName(node) + || (isDeclaredInLoop + && !isCapturedInFunction + && (hierarchyFacts & (2048 | 4096)) === 0)); + return emitExplicitInitializer; + } + function visitVariableDeclarationInLetDeclarationList(node) { + var name = node.name; + if (ts.isBindingPattern(name)) { + return visitVariableDeclaration(node); + } + if (!node.initializer && shouldEmitExplicitInitializerForLetDeclaration(node)) { + var clone_3 = ts.getMutableClone(node); + clone_3.initializer = ts.createVoidZero(); + return clone_3; + } + return ts.visitEachChild(node, visitor, context); + } + function visitVariableDeclaration(node) { + var ancestorFacts = enterSubtree(32, 0); + var updated; + if (ts.isBindingPattern(node.name)) { + updated = ts.flattenDestructuringBinding(node, visitor, context, 0, undefined, (ancestorFacts & 32) !== 0); + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function recordLabel(node) { + convertedLoopState.labels.set(ts.idText(node.label), true); + } + function resetLabel(node) { + convertedLoopState.labels.set(ts.idText(node.label), false); + } + function visitLabeledStatement(node) { + if (convertedLoopState && !convertedLoopState.labels) { + convertedLoopState.labels = ts.createMap(); + } + var statement = ts.unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel); + return ts.isIterationStatement(statement, false) + ? visitIterationStatement(statement, node) + : ts.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, ts.liftToBlock), node, convertedLoopState && resetLabel); + } + function visitIterationStatement(node, outermostLabeledStatement) { + switch (node.kind) { + case 228: + case 229: + return visitDoOrWhileStatement(node, outermostLabeledStatement); + case 230: + return visitForStatement(node, outermostLabeledStatement); + case 231: + return visitForInStatement(node, outermostLabeledStatement); + case 232: + return visitForOfStatement(node, outermostLabeledStatement); + } + } + function visitIterationStatementWithFacts(excludeFacts, includeFacts, node, outermostLabeledStatement, convert) { + var ancestorFacts = enterSubtree(excludeFacts, includeFacts); + var updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert); + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function visitDoOrWhileStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(0, 1280, node, outermostLabeledStatement); + } + function visitForStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(5056, 3328, node, outermostLabeledStatement); + } + function visitForInStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(3008, 5376, node, outermostLabeledStatement); + } + function visitForOfStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(3008, 5376, node, outermostLabeledStatement, compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray); + } + function convertForOfStatementHead(node, boundValue, convertedLoopBodyStatements) { + var statements = []; + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + if (node.initializer.flags & 3) { + enableSubstitutionsForBlockScopedBindings(); + } + var firstOriginalDeclaration = ts.firstOrUndefined(initializer.declarations); + if (firstOriginalDeclaration && ts.isBindingPattern(firstOriginalDeclaration.name)) { + var declarations = ts.flattenDestructuringBinding(firstOriginalDeclaration, visitor, context, 0, boundValue); + var declarationList = ts.setTextRange(ts.createVariableDeclarationList(declarations), node.initializer); + ts.setOriginalNode(declarationList, node.initializer); + ts.setSourceMapRange(declarationList, ts.createRange(declarations[0].pos, ts.last(declarations).end)); + statements.push(ts.createVariableStatement(undefined, declarationList)); + } + else { + statements.push(ts.setTextRange(ts.createVariableStatement(undefined, ts.setOriginalNode(ts.setTextRange(ts.createVariableDeclarationList([ + ts.createVariableDeclaration(firstOriginalDeclaration ? firstOriginalDeclaration.name : ts.createTempVariable(undefined), undefined, boundValue) + ]), ts.moveRangePos(initializer, -1)), initializer)), ts.moveRangeEnd(initializer, -1))); + } + } + else { + var assignment = ts.createAssignment(initializer, boundValue); + if (ts.isDestructuringAssignment(assignment)) { + ts.aggregateTransformFlags(assignment); + statements.push(ts.createExpressionStatement(visitBinaryExpression(assignment, false))); + } + else { + assignment.end = initializer.end; + statements.push(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(assignment, visitor, ts.isExpression)), ts.moveRangeEnd(initializer, -1))); + } + } + if (convertedLoopBodyStatements) { + return createSyntheticBlockForConvertedStatements(ts.addRange(statements, convertedLoopBodyStatements)); + } + else { + var statement = ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock); + if (ts.isBlock(statement)) { + return ts.updateBlock(statement, ts.setTextRange(ts.createNodeArray(ts.concatenate(statements, statement.statements)), statement.statements)); + } + else { + statements.push(statement); + return createSyntheticBlockForConvertedStatements(statements); + } + } + } + function createSyntheticBlockForConvertedStatements(statements) { + return ts.setEmitFlags(ts.createBlock(ts.createNodeArray(statements), true), 48 | 384); + } + function convertForOfStatementForArray(node, outermostLabeledStatement, convertedLoopBodyStatements) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var counter = ts.createLoopVariable(); + var rhsReference = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined); + ts.setEmitFlags(expression, 48 | ts.getEmitFlags(expression)); + var forStatement = ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([ + ts.setTextRange(ts.createVariableDeclaration(counter, undefined, ts.createLiteral(0)), ts.moveRangePos(node.expression, -1)), + ts.setTextRange(ts.createVariableDeclaration(rhsReference, undefined, expression), node.expression) + ]), node.expression), 2097152), ts.setTextRange(ts.createLessThan(counter, ts.createPropertyAccess(rhsReference, "length")), node.expression), ts.setTextRange(ts.createPostfixIncrement(counter), node.expression), convertForOfStatementHead(node, ts.createElementAccess(rhsReference, counter), convertedLoopBodyStatements)), node); + ts.setEmitFlags(forStatement, 256); + ts.setTextRange(forStatement, node); + return ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel); + } + function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var iterator = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined); + var result = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(iterator) : ts.createTempVariable(undefined); + var errorRecord = ts.createUniqueName("e"); + var catchVariable = ts.getGeneratedNameForNode(errorRecord); + var returnMethod = ts.createTempVariable(undefined); + var values = ts.createValuesHelper(context, expression, node.expression); + var next = ts.createCall(ts.createPropertyAccess(iterator, "next"), undefined, []); + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + var initializer = ancestorFacts & 1024 + ? ts.inlineExpressions([ts.createAssignment(errorRecord, ts.createVoidZero()), values]) + : values; + var forStatement = ts.setEmitFlags(ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([ + ts.setTextRange(ts.createVariableDeclaration(iterator, undefined, initializer), node.expression), + ts.createVariableDeclaration(result, undefined, next) + ]), node.expression), 2097152), ts.createLogicalNot(ts.createPropertyAccess(result, "done")), ts.createAssignment(result, next), convertForOfStatementHead(node, ts.createPropertyAccess(result, "value"), convertedLoopBodyStatements)), node), 256); + return ts.createTry(ts.createBlock([ + ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel) + ]), ts.createCatchClause(ts.createVariableDeclaration(catchVariable), ts.setEmitFlags(ts.createBlock([ + ts.createExpressionStatement(ts.createAssignment(errorRecord, ts.createObjectLiteral([ + ts.createPropertyAssignment("error", catchVariable) + ]))) + ]), 1)), ts.createBlock([ + ts.createTry(ts.createBlock([ + ts.setEmitFlags(ts.createIf(ts.createLogicalAnd(ts.createLogicalAnd(result, ts.createLogicalNot(ts.createPropertyAccess(result, "done"))), ts.createAssignment(returnMethod, ts.createPropertyAccess(iterator, "return"))), ts.createExpressionStatement(ts.createFunctionCall(returnMethod, iterator, []))), 1), + ]), undefined, ts.setEmitFlags(ts.createBlock([ + ts.setEmitFlags(ts.createIf(errorRecord, ts.createThrow(ts.createPropertyAccess(errorRecord, "error"))), 1) + ]), 1)) + ])); + } + function visitObjectLiteralExpression(node) { + var properties = node.properties; + var numProperties = properties.length; + var numInitialProperties = numProperties; + var numInitialPropertiesWithoutYield = numProperties; + for (var i = 0; i < numProperties; i++) { + var property = properties[i]; + if ((property.transformFlags & 262144 && hierarchyFacts & 4) + && i < numInitialPropertiesWithoutYield) { + numInitialPropertiesWithoutYield = i; + } + if (property.name.kind === 154) { + numInitialProperties = i; + break; + } + } + if (numInitialProperties !== numProperties) { + if (numInitialPropertiesWithoutYield < numInitialProperties) { + numInitialProperties = numInitialPropertiesWithoutYield; + } + var temp = ts.createTempVariable(hoistVariableDeclaration); + var expressions = []; + var assignment = ts.createAssignment(temp, ts.setEmitFlags(ts.createObjectLiteral(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), node.multiLine), 65536)); + if (node.multiLine) { + ts.startOnNewLine(assignment); + } + expressions.push(assignment); + addObjectLiteralMembers(expressions, node, temp, numInitialProperties); + expressions.push(node.multiLine ? ts.startOnNewLine(ts.getMutableClone(temp)) : temp); + return ts.inlineExpressions(expressions); + } + return ts.visitEachChild(node, visitor, context); + } + function shouldConvertPartOfIterationStatement(node) { + return (resolver.getNodeCheckFlags(node) & 131072) !== 0; + } + function shouldConvertInitializerOfForStatement(node) { + return ts.isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer); + } + function shouldConvertConditionOfForStatement(node) { + return ts.isForStatement(node) && !!node.condition && shouldConvertPartOfIterationStatement(node.condition); + } + function shouldConvertIncrementorOfForStatement(node) { + return ts.isForStatement(node) && !!node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor); + } + function shouldConvertIterationStatement(node) { + return shouldConvertBodyOfIterationStatement(node) + || shouldConvertInitializerOfForStatement(node); + } + function shouldConvertBodyOfIterationStatement(node) { + return (resolver.getNodeCheckFlags(node) & 65536) !== 0; + } + function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) { + if (!state.hoistedLocalVariables) { + state.hoistedLocalVariables = []; + } + visit(node.name); + function visit(node) { + if (node.kind === 75) { + state.hoistedLocalVariables.push(node); + } + else { + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + visit(element.name); + } + } + } + } + } + function convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert) { + if (!shouldConvertIterationStatement(node)) { + var saveAllowedNonLabeledJumps = void 0; + if (convertedLoopState) { + saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps; + convertedLoopState.allowedNonLabeledJumps = 2 | 4; + } + var result = convert + ? convert(node, outermostLabeledStatement, undefined, ancestorFacts) + : ts.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement, convertedLoopState && resetLabel); + if (convertedLoopState) { + convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps; + } + return result; + } + var currentState = createConvertedLoopState(node); + var statements = []; + var outerConvertedLoopState = convertedLoopState; + convertedLoopState = currentState; + var initializerFunction = shouldConvertInitializerOfForStatement(node) ? createFunctionForInitializerOfForStatement(node, currentState) : undefined; + var bodyFunction = shouldConvertBodyOfIterationStatement(node) ? createFunctionForBodyOfIterationStatement(node, currentState, outerConvertedLoopState) : undefined; + convertedLoopState = outerConvertedLoopState; + if (initializerFunction) + statements.push(initializerFunction.functionDeclaration); + if (bodyFunction) + statements.push(bodyFunction.functionDeclaration); + addExtraDeclarationsForConvertedLoop(statements, currentState, outerConvertedLoopState); + if (initializerFunction) { + statements.push(generateCallToConvertedLoopInitializer(initializerFunction.functionName, initializerFunction.containsYield)); + } + var loop; + if (bodyFunction) { + if (convert) { + loop = convert(node, outermostLabeledStatement, bodyFunction.part, ancestorFacts); + } + else { + var clone_4 = convertIterationStatementCore(node, initializerFunction, ts.createBlock(bodyFunction.part, true)); + ts.aggregateTransformFlags(clone_4); + loop = ts.restoreEnclosingLabel(clone_4, outermostLabeledStatement, convertedLoopState && resetLabel); + } + } + else { + var clone_5 = convertIterationStatementCore(node, initializerFunction, ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + ts.aggregateTransformFlags(clone_5); + loop = ts.restoreEnclosingLabel(clone_5, outermostLabeledStatement, convertedLoopState && resetLabel); + } + statements.push(loop); + return statements; + } + function convertIterationStatementCore(node, initializerFunction, convertedLoopBody) { + switch (node.kind) { + case 230: return convertForStatement(node, initializerFunction, convertedLoopBody); + case 231: return convertForInStatement(node, convertedLoopBody); + case 232: return convertForOfStatement(node, convertedLoopBody); + case 228: return convertDoStatement(node, convertedLoopBody); + case 229: return convertWhileStatement(node, convertedLoopBody); + default: return ts.Debug.failBadSyntaxKind(node, "IterationStatement expected"); + } + } + function convertForStatement(node, initializerFunction, convertedLoopBody) { + var shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition); + var shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor); + return ts.updateFor(node, ts.visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitor, ts.isForInitializer), ts.visitNode(shouldConvertCondition ? undefined : node.condition, visitor, ts.isExpression), ts.visitNode(shouldConvertIncrementor ? undefined : node.incrementor, visitor, ts.isExpression), convertedLoopBody); + } + function convertForOfStatement(node, convertedLoopBody) { + return ts.updateForOf(node, undefined, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function convertForInStatement(node, convertedLoopBody) { + return ts.updateForIn(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function convertDoStatement(node, convertedLoopBody) { + return ts.updateDo(node, convertedLoopBody, ts.visitNode(node.expression, visitor, ts.isExpression)); + } + function convertWhileStatement(node, convertedLoopBody) { + return ts.updateWhile(node, ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function createConvertedLoopState(node) { + var loopInitializer; + switch (node.kind) { + case 230: + case 231: + case 232: + var initializer = node.initializer; + if (initializer && initializer.kind === 243) { + loopInitializer = initializer; + } + break; + } + var loopParameters = []; + var loopOutParameters = []; + if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 3)) { + var hasCapturedBindingsInForInitializer = shouldConvertInitializerOfForStatement(node); + for (var _i = 0, _a = loopInitializer.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer); + } + } + var currentState = { loopParameters: loopParameters, loopOutParameters: loopOutParameters }; + if (convertedLoopState) { + if (convertedLoopState.argumentsName) { + currentState.argumentsName = convertedLoopState.argumentsName; + } + if (convertedLoopState.thisName) { + currentState.thisName = convertedLoopState.thisName; + } + if (convertedLoopState.hoistedLocalVariables) { + currentState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables; + } + } + return currentState; + } + function addExtraDeclarationsForConvertedLoop(statements, state, outerState) { + var extraVariableDeclarations; + if (state.argumentsName) { + if (outerState) { + outerState.argumentsName = state.argumentsName; + } + else { + (extraVariableDeclarations || (extraVariableDeclarations = [])).push(ts.createVariableDeclaration(state.argumentsName, undefined, ts.createIdentifier("arguments"))); + } + } + if (state.thisName) { + if (outerState) { + outerState.thisName = state.thisName; + } + else { + (extraVariableDeclarations || (extraVariableDeclarations = [])).push(ts.createVariableDeclaration(state.thisName, undefined, ts.createIdentifier("this"))); + } + } + if (state.hoistedLocalVariables) { + if (outerState) { + outerState.hoistedLocalVariables = state.hoistedLocalVariables; + } + else { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + for (var _i = 0, _a = state.hoistedLocalVariables; _i < _a.length; _i++) { + var identifier = _a[_i]; + extraVariableDeclarations.push(ts.createVariableDeclaration(identifier)); + } + } + } + if (state.loopOutParameters.length) { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + for (var _b = 0, _c = state.loopOutParameters; _b < _c.length; _b++) { + var outParam = _c[_b]; + extraVariableDeclarations.push(ts.createVariableDeclaration(outParam.outParamName)); + } + } + if (state.conditionVariable) { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + extraVariableDeclarations.push(ts.createVariableDeclaration(state.conditionVariable, undefined, ts.createFalse())); + } + if (extraVariableDeclarations) { + statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(extraVariableDeclarations))); + } + } + function createOutVariable(p) { + return ts.createVariableDeclaration(p.originalName, undefined, p.outParamName); + } + function createFunctionForInitializerOfForStatement(node, currentState) { + var functionName = ts.createUniqueName("_loop_init"); + var containsYield = (node.initializer.transformFlags & 262144) !== 0; + var emitFlags = 0; + if (currentState.containsLexicalThis) + emitFlags |= 8; + if (containsYield && hierarchyFacts & 4) + emitFlags |= 262144; + var statements = []; + statements.push(ts.createVariableStatement(undefined, node.initializer)); + copyOutParameters(currentState.loopOutParameters, 2, 1, statements); + var functionDeclaration = ts.createVariableStatement(undefined, ts.setEmitFlags(ts.createVariableDeclarationList([ + ts.createVariableDeclaration(functionName, undefined, ts.setEmitFlags(ts.createFunctionExpression(undefined, containsYield ? ts.createToken(41) : undefined, undefined, undefined, undefined, undefined, ts.visitNode(ts.createBlock(statements, true), visitor, ts.isBlock)), emitFlags)) + ]), 2097152)); + var part = ts.createVariableDeclarationList(ts.map(currentState.loopOutParameters, createOutVariable)); + return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part }; + } + function createFunctionForBodyOfIterationStatement(node, currentState, outerState) { + var functionName = ts.createUniqueName("_loop"); + startLexicalEnvironment(); + var statement = ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock); + var lexicalEnvironment = endLexicalEnvironment(); + var statements = []; + if (shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node)) { + currentState.conditionVariable = ts.createUniqueName("inc"); + statements.push(ts.createIf(currentState.conditionVariable, ts.createStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), ts.createStatement(ts.createAssignment(currentState.conditionVariable, ts.createTrue())))); + if (shouldConvertConditionOfForStatement(node)) { + statements.push(ts.createIf(ts.createPrefix(53, ts.visitNode(node.condition, visitor, ts.isExpression)), ts.visitNode(ts.createBreak(), visitor, ts.isStatement))); + } + } + if (ts.isBlock(statement)) { + ts.addRange(statements, statement.statements); + } + else { + statements.push(statement); + } + copyOutParameters(currentState.loopOutParameters, 1, 1, statements); + ts.insertStatementsAfterStandardPrologue(statements, lexicalEnvironment); + var loopBody = ts.createBlock(statements, true); + if (ts.isBlock(statement)) + ts.setOriginalNode(loopBody, statement); + var containsYield = (node.statement.transformFlags & 262144) !== 0; + var emitFlags = 0; + if (currentState.containsLexicalThis) + emitFlags |= 8; + if (containsYield && (hierarchyFacts & 4) !== 0) + emitFlags |= 262144; + var functionDeclaration = ts.createVariableStatement(undefined, ts.setEmitFlags(ts.createVariableDeclarationList([ + ts.createVariableDeclaration(functionName, undefined, ts.setEmitFlags(ts.createFunctionExpression(undefined, containsYield ? ts.createToken(41) : undefined, undefined, undefined, currentState.loopParameters, undefined, loopBody), emitFlags)) + ]), 2097152)); + var part = generateCallToConvertedLoop(functionName, currentState, outerState, containsYield); + return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part }; + } + function copyOutParameter(outParam, copyDirection) { + var source = copyDirection === 0 ? outParam.outParamName : outParam.originalName; + var target = copyDirection === 0 ? outParam.originalName : outParam.outParamName; + return ts.createBinary(target, 62, source); + } + function copyOutParameters(outParams, partFlags, copyDirection, statements) { + for (var _i = 0, outParams_1 = outParams; _i < outParams_1.length; _i++) { + var outParam = outParams_1[_i]; + if (outParam.flags & partFlags) { + statements.push(ts.createExpressionStatement(copyOutParameter(outParam, copyDirection))); + } + } + } + function generateCallToConvertedLoopInitializer(initFunctionExpressionName, containsYield) { + var call = ts.createCall(initFunctionExpressionName, undefined, []); + var callResult = containsYield + ? ts.createYield(ts.createToken(41), ts.setEmitFlags(call, 8388608)) + : call; + return ts.createStatement(callResult); + } + function generateCallToConvertedLoop(loopFunctionExpressionName, state, outerState, containsYield) { + var statements = []; + var isSimpleLoop = !(state.nonLocalJumps & ~4) && + !state.labeledNonLocalBreaks && + !state.labeledNonLocalContinues; + var call = ts.createCall(loopFunctionExpressionName, undefined, ts.map(state.loopParameters, function (p) { return p.name; })); + var callResult = containsYield + ? ts.createYield(ts.createToken(41), ts.setEmitFlags(call, 8388608)) + : call; + if (isSimpleLoop) { + statements.push(ts.createExpressionStatement(callResult)); + copyOutParameters(state.loopOutParameters, 1, 0, statements); + } + else { + var loopResultName = ts.createUniqueName("state"); + var stateVariable = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ts.createVariableDeclaration(loopResultName, undefined, callResult)])); + statements.push(stateVariable); + copyOutParameters(state.loopOutParameters, 1, 0, statements); + if (state.nonLocalJumps & 8) { + var returnStatement = void 0; + if (outerState) { + outerState.nonLocalJumps |= 8; + returnStatement = ts.createReturn(loopResultName); + } + else { + returnStatement = ts.createReturn(ts.createPropertyAccess(loopResultName, "value")); + } + statements.push(ts.createIf(ts.createBinary(ts.createTypeOf(loopResultName), 36, ts.createLiteral("object")), returnStatement)); + } + if (state.nonLocalJumps & 2) { + statements.push(ts.createIf(ts.createBinary(loopResultName, 36, ts.createLiteral("break")), ts.createBreak())); + } + if (state.labeledNonLocalBreaks || state.labeledNonLocalContinues) { + var caseClauses = []; + processLabeledJumps(state.labeledNonLocalBreaks, true, loopResultName, outerState, caseClauses); + processLabeledJumps(state.labeledNonLocalContinues, false, loopResultName, outerState, caseClauses); + statements.push(ts.createSwitch(loopResultName, ts.createCaseBlock(caseClauses))); + } + } + return statements; + } + function setLabeledJump(state, isBreak, labelText, labelMarker) { + if (isBreak) { + if (!state.labeledNonLocalBreaks) { + state.labeledNonLocalBreaks = ts.createMap(); + } + state.labeledNonLocalBreaks.set(labelText, labelMarker); + } + else { + if (!state.labeledNonLocalContinues) { + state.labeledNonLocalContinues = ts.createMap(); + } + state.labeledNonLocalContinues.set(labelText, labelMarker); + } + } + function processLabeledJumps(table, isBreak, loopResultName, outerLoop, caseClauses) { + if (!table) { + return; + } + table.forEach(function (labelMarker, labelText) { + var statements = []; + if (!outerLoop || (outerLoop.labels && outerLoop.labels.get(labelText))) { + var label = ts.createIdentifier(labelText); + statements.push(isBreak ? ts.createBreak(label) : ts.createContinue(label)); + } + else { + setLabeledJump(outerLoop, isBreak, labelText, labelMarker); + statements.push(ts.createReturn(loopResultName)); + } + caseClauses.push(ts.createCaseClause(ts.createLiteral(labelMarker), statements)); + }); + } + function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer) { + var name = decl.name; + if (ts.isBindingPattern(name)) { + for (var _i = 0, _a = name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer); + } + } + } + else { + loopParameters.push(ts.createParameter(undefined, undefined, undefined, name)); + var checkFlags = resolver.getNodeCheckFlags(decl); + if (checkFlags & 4194304 || hasCapturedBindingsInForInitializer) { + var outParamName = ts.createUniqueName("out_" + ts.idText(name)); + var flags = 0; + if (checkFlags & 4194304) { + flags |= 1; + } + if (ts.isForStatement(container) && container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) { + flags |= 2; + } + loopOutParameters.push({ flags: flags, originalName: name, outParamName: outParamName }); + } + } + } + function addObjectLiteralMembers(expressions, node, receiver, start) { + var properties = node.properties; + var numProperties = properties.length; + for (var i = start; i < numProperties; i++) { + var property = properties[i]; + switch (property.kind) { + case 163: + case 164: + var accessors = ts.getAllAccessorDeclarations(node.properties, property); + if (property === accessors.firstAccessor) { + expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine)); + } + break; + case 161: + expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine)); + break; + case 281: + expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine)); + break; + case 282: + expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine)); + break; + default: + ts.Debug.failBadSyntaxKind(node); + break; + } + } + } + function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) { + var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.visitNode(property.initializer, visitor, ts.isExpression)); + ts.setTextRange(expression, property); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) { + var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.getSynthesizedClone(property.name)); + ts.setTextRange(expression, property); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + function transformObjectLiteralMethodDeclarationToExpression(method, receiver, container, startsOnNewLine) { + var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(method.name, visitor, ts.isPropertyName)), transformFunctionLikeToExpression(method, method, undefined, container)); + ts.setTextRange(expression, method); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + function visitCatchClause(node) { + var ancestorFacts = enterSubtree(7104, 0); + var updated; + ts.Debug.assert(!!node.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015."); + if (ts.isBindingPattern(node.variableDeclaration.name)) { + var temp = ts.createTempVariable(undefined); + var newVariableDeclaration = ts.createVariableDeclaration(temp); + ts.setTextRange(newVariableDeclaration, node.variableDeclaration); + var vars = ts.flattenDestructuringBinding(node.variableDeclaration, visitor, context, 0, temp); + var list = ts.createVariableDeclarationList(vars); + ts.setTextRange(list, node.variableDeclaration); + var destructure = ts.createVariableStatement(undefined, list); + updated = ts.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure)); + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0, 0); + return updated; + } + function addStatementToStartOfBlock(block, statement) { + var transformedStatements = ts.visitNodes(block.statements, visitor, ts.isStatement); + return ts.updateBlock(block, __spreadArrays([statement], transformedStatements)); + } + function visitMethodDeclaration(node) { + ts.Debug.assert(!ts.isComputedPropertyName(node.name)); + var functionExpression = transformFunctionLikeToExpression(node, ts.moveRangePos(node, -1), undefined, undefined); + ts.setEmitFlags(functionExpression, 512 | ts.getEmitFlags(functionExpression)); + return ts.setTextRange(ts.createPropertyAssignment(node.name, functionExpression), node); + } + function visitAccessorDeclaration(node) { + ts.Debug.assert(!ts.isComputedPropertyName(node.name)); + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(16286, 65); + var updated; + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + if (node.kind === 163) { + updated = ts.updateGetAccessor(node, node.decorators, node.modifiers, node.name, parameters, node.type, body); + } + else { + updated = ts.updateSetAccessor(node, node.decorators, node.modifiers, node.name, parameters, body); + } + exitSubtree(ancestorFacts, 49152, 0); + convertedLoopState = savedConvertedLoopState; + return updated; + } + function visitShorthandPropertyAssignment(node) { + return ts.setTextRange(ts.createPropertyAssignment(node.name, ts.getSynthesizedClone(node.name)), node); + } + function visitComputedPropertyName(node) { + return ts.visitEachChild(node, visitor, context); + } + function visitYieldExpression(node) { + return ts.visitEachChild(node, visitor, context); + } + function visitArrayLiteralExpression(node) { + if (ts.some(node.elements, ts.isSpreadElement)) { + return transformAndSpreadElements(node.elements, true, !!node.multiLine, !!node.elements.hasTrailingComma); + } + return ts.visitEachChild(node, visitor, context); + } + function visitCallExpression(node) { + if (ts.getEmitFlags(node) & 33554432) { + return visitTypeScriptClassWrapper(node); + } + var expression = ts.skipOuterExpressions(node.expression); + if (expression.kind === 102 || + ts.isSuperProperty(expression) || + ts.some(node.arguments, ts.isSpreadElement)) { + return visitCallExpressionWithPotentialCapturedThisAssignment(node, true); + } + return ts.updateCall(node, ts.visitNode(node.expression, callExpressionVisitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitTypeScriptClassWrapper(node) { + var body = ts.cast(ts.cast(ts.skipOuterExpressions(node.expression), ts.isArrowFunction).body, ts.isBlock); + var isVariableStatementWithInitializer = function (stmt) { return ts.isVariableStatement(stmt) && !!ts.first(stmt.declarationList.declarations).initializer; }; + var bodyStatements = ts.visitNodes(body.statements, visitor, ts.isStatement); + var classStatements = ts.filter(bodyStatements, isVariableStatementWithInitializer); + var remainingStatements = ts.filter(bodyStatements, function (stmt) { return !isVariableStatementWithInitializer(stmt); }); + var varStatement = ts.cast(ts.first(classStatements), ts.isVariableStatement); + var variable = varStatement.declarationList.declarations[0]; + var initializer = ts.skipOuterExpressions(variable.initializer); + var aliasAssignment = ts.tryCast(initializer, ts.isAssignmentExpression); + var call = ts.cast(aliasAssignment ? ts.skipOuterExpressions(aliasAssignment.right) : initializer, ts.isCallExpression); + var func = ts.cast(ts.skipOuterExpressions(call.expression), ts.isFunctionExpression); + var funcStatements = func.body.statements; + var classBodyStart = 0; + var classBodyEnd = -1; + var statements = []; + if (aliasAssignment) { + var extendsCall = ts.tryCast(funcStatements[classBodyStart], ts.isExpressionStatement); + if (extendsCall) { + statements.push(extendsCall); + classBodyStart++; + } + statements.push(funcStatements[classBodyStart]); + classBodyStart++; + statements.push(ts.createExpressionStatement(ts.createAssignment(aliasAssignment.left, ts.cast(variable.name, ts.isIdentifier)))); + } + while (!ts.isReturnStatement(ts.elementAt(funcStatements, classBodyEnd))) { + classBodyEnd--; + } + ts.addRange(statements, funcStatements, classBodyStart, classBodyEnd); + if (classBodyEnd < -1) { + ts.addRange(statements, funcStatements, classBodyEnd + 1); + } + ts.addRange(statements, remainingStatements); + ts.addRange(statements, classStatements, 1); + return ts.recreateOuterExpressions(node.expression, ts.recreateOuterExpressions(variable.initializer, ts.recreateOuterExpressions(aliasAssignment && aliasAssignment.right, ts.updateCall(call, ts.recreateOuterExpressions(call.expression, ts.updateFunctionExpression(func, undefined, undefined, undefined, undefined, func.parameters, undefined, ts.updateBlock(func.body, statements))), undefined, call.arguments)))); + } + function visitImmediateSuperCallInBody(node) { + return visitCallExpressionWithPotentialCapturedThisAssignment(node, false); + } + function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) { + if (node.transformFlags & 8192 || + node.expression.kind === 102 || + ts.isSuperProperty(ts.skipOuterExpressions(node.expression))) { + var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + if (node.expression.kind === 102) { + ts.setEmitFlags(thisArg, 4); + } + var resultingCall = void 0; + if (node.transformFlags & 8192) { + resultingCall = ts.createFunctionApply(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 102 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), transformAndSpreadElements(node.arguments, false, false, false)); + } + else { + resultingCall = ts.createFunctionCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 102 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), ts.visitNodes(node.arguments, visitor, ts.isExpression), node); + } + if (node.expression.kind === 102) { + var initializer = ts.createLogicalOr(resultingCall, createActualThis()); + resultingCall = assignToCapturedThis + ? ts.createAssignment(ts.createFileLevelUniqueName("_this"), initializer) + : initializer; + } + return ts.setOriginalNode(resultingCall, node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitNewExpression(node) { + if (ts.some(node.arguments, ts.isSpreadElement)) { + var _a = ts.createCallBinding(ts.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + return ts.createNew(ts.createFunctionApply(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(ts.createNodeArray(__spreadArrays([ts.createVoidZero()], node.arguments)), false, false, false)), undefined, []); + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndSpreadElements(elements, needsUniqueCopy, multiLine, hasTrailingComma) { + var numElements = elements.length; + var segments = ts.flatten(ts.spanMap(elements, partitionSpread, function (partition, visitPartition, _start, end) { + return visitPartition(partition, multiLine, hasTrailingComma && end === numElements); + })); + if (compilerOptions.downlevelIteration) { + if (segments.length === 1) { + var firstSegment = segments[0]; + if (isCallToHelper(firstSegment, "___spread")) { + return segments[0]; + } + } + return ts.createSpreadHelper(context, segments); + } + else { + if (segments.length === 1) { + var firstSegment = segments[0]; + if (!needsUniqueCopy + || isPackedArrayLiteral(firstSegment) + || isCallToHelper(firstSegment, "___spreadArrays")) { + return segments[0]; + } + } + return ts.createSpreadArraysHelper(context, segments); + } + } + function isPackedElement(node) { + return !ts.isOmittedExpression(node); + } + function isPackedArrayLiteral(node) { + return ts.isArrayLiteralExpression(node) && ts.every(node.elements, isPackedElement); + } + function isCallToHelper(firstSegment, helperName) { + return ts.isCallExpression(firstSegment) + && ts.isIdentifier(firstSegment.expression) + && (ts.getEmitFlags(firstSegment.expression) & 4096) + && firstSegment.expression.escapedText === helperName; + } + function partitionSpread(node) { + return ts.isSpreadElement(node) + ? visitSpanOfSpreads + : visitSpanOfNonSpreads; + } + function visitSpanOfSpreads(chunk) { + return ts.map(chunk, visitExpressionOfSpread); + } + function visitSpanOfNonSpreads(chunk, multiLine, hasTrailingComma) { + return ts.createArrayLiteral(ts.visitNodes(ts.createNodeArray(chunk, hasTrailingComma), visitor, ts.isExpression), multiLine); + } + function visitSpreadElement(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + function visitExpressionOfSpread(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + function visitTemplateLiteral(node) { + return ts.setTextRange(ts.createLiteral(node.text), node); + } + function visitStringLiteral(node) { + if (node.hasExtendedUnicodeEscape) { + return ts.setTextRange(ts.createLiteral(node.text), node); + } + return node; + } + function visitNumericLiteral(node) { + if (node.numericLiteralFlags & 384) { + return ts.setTextRange(ts.createNumericLiteral(node.text), node); + } + return node; + } + function visitTaggedTemplateExpression(node) { + var tag = ts.visitNode(node.tag, visitor, ts.isExpression); + var templateArguments = [undefined]; + var cookedStrings = []; + var rawStrings = []; + var template = node.template; + if (ts.isNoSubstitutionTemplateLiteral(template)) { + cookedStrings.push(ts.createLiteral(template.text)); + rawStrings.push(getRawLiteral(template)); + } + else { + cookedStrings.push(ts.createLiteral(template.head.text)); + rawStrings.push(getRawLiteral(template.head)); + for (var _i = 0, _a = template.templateSpans; _i < _a.length; _i++) { + var templateSpan = _a[_i]; + cookedStrings.push(ts.createLiteral(templateSpan.literal.text)); + rawStrings.push(getRawLiteral(templateSpan.literal)); + templateArguments.push(ts.visitNode(templateSpan.expression, visitor, ts.isExpression)); + } + } + var helperCall = createTemplateObjectHelper(context, ts.createArrayLiteral(cookedStrings), ts.createArrayLiteral(rawStrings)); + if (ts.isExternalModule(currentSourceFile)) { + var tempVar = ts.createUniqueName("templateObject"); + recordTaggedTemplateString(tempVar); + templateArguments[0] = ts.createLogicalOr(tempVar, ts.createAssignment(tempVar, helperCall)); + } + else { + templateArguments[0] = helperCall; + } + return ts.createCall(tag, undefined, templateArguments); + } + function getRawLiteral(node) { + var text = node.rawText; + if (text === undefined) { + text = ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node); + var isLast = node.kind === 14 || node.kind === 17; + text = text.substring(1, text.length - (isLast ? 1 : 2)); + } + text = text.replace(/\r\n?/g, "\n"); + return ts.setTextRange(ts.createLiteral(text), node); + } + function visitTemplateExpression(node) { + var expressions = []; + addTemplateHead(expressions, node); + addTemplateSpans(expressions, node); + var expression = ts.reduceLeft(expressions, ts.createAdd); + if (ts.nodeIsSynthesized(expression)) { + expression.pos = node.pos; + expression.end = node.end; + } + return expression; + } + function shouldAddTemplateHead(node) { + ts.Debug.assert(node.templateSpans.length !== 0); + return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; + } + function addTemplateHead(expressions, node) { + if (!shouldAddTemplateHead(node)) { + return; + } + expressions.push(ts.createLiteral(node.head.text)); + } + function addTemplateSpans(expressions, node) { + for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) { + var span = _a[_i]; + expressions.push(ts.visitNode(span.expression, visitor, ts.isExpression)); + if (span.literal.text.length !== 0) { + expressions.push(ts.createLiteral(span.literal.text)); + } + } + } + function visitSuperKeyword(isExpressionOfCall) { + return hierarchyFacts & 8 && !isExpressionOfCall ? ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), "prototype") : + ts.createFileLevelUniqueName("_super"); + } + function visitMetaProperty(node) { + if (node.keywordToken === 99 && node.name.escapedText === "target") { + hierarchyFacts |= 16384; + return ts.createFileLevelUniqueName("_newTarget"); + } + return node; + } + function onEmitNode(hint, node, emitCallback) { + if (enabledSubstitutions & 1 && ts.isFunctionLike(node)) { + var ancestorFacts = enterSubtree(16286, ts.getEmitFlags(node) & 8 + ? 65 | 16 + : 65); + previousOnEmitNode(hint, node, emitCallback); + exitSubtree(ancestorFacts, 0, 0); + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + function enableSubstitutionsForBlockScopedBindings() { + if ((enabledSubstitutions & 2) === 0) { + enabledSubstitutions |= 2; + context.enableSubstitution(75); + } + } + function enableSubstitutionsForCapturedThis() { + if ((enabledSubstitutions & 1) === 0) { + enabledSubstitutions |= 1; + context.enableSubstitution(104); + context.enableEmitNotification(162); + context.enableEmitNotification(161); + context.enableEmitNotification(163); + context.enableEmitNotification(164); + context.enableEmitNotification(202); + context.enableEmitNotification(201); + context.enableEmitNotification(244); + } + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1) { + return substituteExpression(node); + } + if (ts.isIdentifier(node)) { + return substituteIdentifier(node); + } + return node; + } + function substituteIdentifier(node) { + if (enabledSubstitutions & 2 && !ts.isInternalName(node)) { + var original = ts.getParseTreeNode(node, ts.isIdentifier); + if (original && isNameOfDeclarationWithCollidingName(original)) { + return ts.setTextRange(ts.getGeneratedNameForNode(original), node); + } + } + return node; + } + function isNameOfDeclarationWithCollidingName(node) { + switch (node.parent.kind) { + case 191: + case 245: + case 248: + case 242: + return node.parent.name === node + && resolver.isDeclarationWithCollidingName(node.parent); + } + return false; + } + function substituteExpression(node) { + switch (node.kind) { + case 75: + return substituteExpressionIdentifier(node); + case 104: + return substituteThisKeyword(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + if (enabledSubstitutions & 2 && !ts.isInternalName(node)) { + var declaration = resolver.getReferencedDeclarationWithCollidingName(node); + if (declaration && !(ts.isClassLike(declaration) && isPartOfClassBody(declaration, node))) { + return ts.setTextRange(ts.getGeneratedNameForNode(ts.getNameOfDeclaration(declaration)), node); + } + } + return node; + } + function isPartOfClassBody(declaration, node) { + var currentNode = ts.getParseTreeNode(node); + if (!currentNode || currentNode === declaration || currentNode.end <= declaration.pos || currentNode.pos >= declaration.end) { + return false; + } + var blockScope = ts.getEnclosingBlockScopeContainer(declaration); + while (currentNode) { + if (currentNode === blockScope || currentNode === declaration) { + return false; + } + if (ts.isClassElement(currentNode) && currentNode.parent === declaration) { + return true; + } + currentNode = currentNode.parent; + } + return false; + } + function substituteThisKeyword(node) { + if (enabledSubstitutions & 1 + && hierarchyFacts & 16) { + return ts.setTextRange(ts.createFileLevelUniqueName("_this"), node); + } + return node; + } + function getClassMemberPrefix(node, member) { + return ts.hasModifier(member, 32) + ? ts.getInternalName(node) + : ts.createPropertyAccess(ts.getInternalName(node), "prototype"); + } + function hasSynthesizedDefaultSuperCall(constructor, hasExtendsClause) { + if (!constructor || !hasExtendsClause) { + return false; + } + if (ts.some(constructor.parameters)) { + return false; + } + var statement = ts.firstOrUndefined(constructor.body.statements); + if (!statement || !ts.nodeIsSynthesized(statement) || statement.kind !== 226) { + return false; + } + var statementExpression = statement.expression; + if (!ts.nodeIsSynthesized(statementExpression) || statementExpression.kind !== 196) { + return false; + } + var callTarget = statementExpression.expression; + if (!ts.nodeIsSynthesized(callTarget) || callTarget.kind !== 102) { + return false; + } + var callArgument = ts.singleOrUndefined(statementExpression.arguments); + if (!callArgument || !ts.nodeIsSynthesized(callArgument) || callArgument.kind !== 213) { + return false; + } + var expression = callArgument.expression; + return ts.isIdentifier(expression) && expression.escapedText === "arguments"; + } + } + ts.transformES2015 = transformES2015; + function createExtendsHelper(context, name) { + context.requestEmitHelper(ts.extendsHelper); + return ts.createCall(ts.getUnscopedHelperName("__extends"), undefined, [ + name, + ts.createFileLevelUniqueName("_super") + ]); + } + function createTemplateObjectHelper(context, cooked, raw) { + context.requestEmitHelper(ts.templateObjectHelper); + return ts.createCall(ts.getUnscopedHelperName("__makeTemplateObject"), undefined, [ + cooked, + raw + ]); + } + ts.extendsHelper = { + name: "typescript:extends", + importName: "__extends", + scoped: false, + priority: 0, + text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();" + }; + ts.templateObjectHelper = { + name: "typescript:makeTemplateObject", + importName: "__makeTemplateObject", + scoped: false, + priority: 0, + text: "\n var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n return cooked;\n };" + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformES5(context) { + var compilerOptions = context.getCompilerOptions(); + var previousOnEmitNode; + var noSubstitution; + if (compilerOptions.jsx === 1 || compilerOptions.jsx === 3) { + previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + context.enableEmitNotification(268); + context.enableEmitNotification(269); + context.enableEmitNotification(267); + noSubstitution = []; + } + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + context.enableSubstitution(194); + context.enableSubstitution(281); + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + return node; + } + function onEmitNode(hint, node, emitCallback) { + switch (node.kind) { + case 268: + case 269: + case 267: + var tagName = node.tagName; + noSubstitution[ts.getOriginalNodeId(tagName)] = true; + break; + } + previousOnEmitNode(hint, node, emitCallback); + } + function onSubstituteNode(hint, node) { + if (node.id && noSubstitution && noSubstitution[node.id]) { + return previousOnSubstituteNode(hint, node); + } + node = previousOnSubstituteNode(hint, node); + if (ts.isPropertyAccessExpression(node)) { + return substitutePropertyAccessExpression(node); + } + else if (ts.isPropertyAssignment(node)) { + return substitutePropertyAssignment(node); + } + return node; + } + function substitutePropertyAccessExpression(node) { + if (ts.isPrivateIdentifier(node.name)) { + return node; + } + var literalName = trySubstituteReservedName(node.name); + if (literalName) { + return ts.setTextRange(ts.createElementAccess(node.expression, literalName), node); + } + return node; + } + function substitutePropertyAssignment(node) { + var literalName = ts.isIdentifier(node.name) && trySubstituteReservedName(node.name); + if (literalName) { + return ts.updatePropertyAssignment(node, literalName, node.initializer); + } + return node; + } + function trySubstituteReservedName(name) { + var token = name.originalKeywordKind || (ts.nodeIsSynthesized(name) ? ts.stringToToken(ts.idText(name)) : undefined); + if (token !== undefined && token >= 77 && token <= 112) { + return ts.setTextRange(ts.createLiteral(name), name); + } + return undefined; + } + } + ts.transformES5 = transformES5; +})(ts || (ts = {})); +var ts; +(function (ts) { + function getInstructionName(instruction) { + switch (instruction) { + case 2: return "return"; + case 3: return "break"; + case 4: return "yield"; + case 5: return "yield*"; + case 7: return "endfinally"; + default: return undefined; + } + } + function transformGenerators(context) { + var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistFunctionDeclaration = context.hoistFunctionDeclaration, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var resolver = context.getEmitResolver(); + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var renamedCatchVariables; + var renamedCatchVariableDeclarations; + var inGeneratorFunctionBody; + var inStatementContainingYield; + var blocks; + var blockOffsets; + var blockActions; + var blockStack; + var labelOffsets; + var labelExpressions; + var nextLabelId = 1; + var operations; + var operationArguments; + var operationLocations; + var state; + var blockIndex = 0; + var labelNumber = 0; + var labelNumbers; + var lastOperationWasAbrupt; + var lastOperationWasCompletion; + var clauses; + var statements; + var exceptionBlockStack; + var currentExceptionBlock; + var withBlockStack; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile || (node.transformFlags & 512) === 0) { + return node; + } + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function visitor(node) { + var transformFlags = node.transformFlags; + if (inStatementContainingYield) { + return visitJavaScriptInStatementContainingYield(node); + } + else if (inGeneratorFunctionBody) { + return visitJavaScriptInGeneratorFunctionBody(node); + } + else if (ts.isFunctionLikeDeclaration(node) && node.asteriskToken) { + return visitGenerator(node); + } + else if (transformFlags & 512) { + return ts.visitEachChild(node, visitor, context); + } + else { + return node; + } + } + function visitJavaScriptInStatementContainingYield(node) { + switch (node.kind) { + case 228: + return visitDoStatement(node); + case 229: + return visitWhileStatement(node); + case 237: + return visitSwitchStatement(node); + case 238: + return visitLabeledStatement(node); + default: + return visitJavaScriptInGeneratorFunctionBody(node); + } + } + function visitJavaScriptInGeneratorFunctionBody(node) { + switch (node.kind) { + case 244: + return visitFunctionDeclaration(node); + case 201: + return visitFunctionExpression(node); + case 163: + case 164: + return visitAccessorDeclaration(node); + case 225: + return visitVariableStatement(node); + case 230: + return visitForStatement(node); + case 231: + return visitForInStatement(node); + case 234: + return visitBreakStatement(node); + case 233: + return visitContinueStatement(node); + case 235: + return visitReturnStatement(node); + default: + if (node.transformFlags & 262144) { + return visitJavaScriptContainingYield(node); + } + else if (node.transformFlags & (512 | 1048576)) { + return ts.visitEachChild(node, visitor, context); + } + else { + return node; + } + } + } + function visitJavaScriptContainingYield(node) { + switch (node.kind) { + case 209: + return visitBinaryExpression(node); + case 210: + return visitConditionalExpression(node); + case 212: + return visitYieldExpression(node); + case 192: + return visitArrayLiteralExpression(node); + case 193: + return visitObjectLiteralExpression(node); + case 195: + return visitElementAccessExpression(node); + case 196: + return visitCallExpression(node); + case 197: + return visitNewExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitGenerator(node) { + switch (node.kind) { + case 244: + return visitFunctionDeclaration(node); + case 201: + return visitFunctionExpression(node); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function visitFunctionDeclaration(node) { + if (node.asteriskToken) { + node = ts.setOriginalNode(ts.setTextRange(ts.createFunctionDeclaration(undefined, node.modifiers, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node); + } + else { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + } + if (inGeneratorFunctionBody) { + hoistFunctionDeclaration(node); + return undefined; + } + else { + return node; + } + } + function visitFunctionExpression(node) { + if (node.asteriskToken) { + node = ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(undefined, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node); + } + else { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + } + return node; + } + function visitAccessorDeclaration(node) { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + return node; + } + function transformGeneratorFunctionBody(body) { + var statements = []; + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + var savedBlocks = blocks; + var savedBlockOffsets = blockOffsets; + var savedBlockActions = blockActions; + var savedBlockStack = blockStack; + var savedLabelOffsets = labelOffsets; + var savedLabelExpressions = labelExpressions; + var savedNextLabelId = nextLabelId; + var savedOperations = operations; + var savedOperationArguments = operationArguments; + var savedOperationLocations = operationLocations; + var savedState = state; + inGeneratorFunctionBody = true; + inStatementContainingYield = false; + blocks = undefined; + blockOffsets = undefined; + blockActions = undefined; + blockStack = undefined; + labelOffsets = undefined; + labelExpressions = undefined; + nextLabelId = 1; + operations = undefined; + operationArguments = undefined; + operationLocations = undefined; + state = ts.createTempVariable(undefined); + resumeLexicalEnvironment(); + var statementOffset = ts.addPrologue(statements, body.statements, false, visitor); + transformAndEmitStatements(body.statements, statementOffset); + var buildResult = build(); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + statements.push(ts.createReturn(buildResult)); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + blocks = savedBlocks; + blockOffsets = savedBlockOffsets; + blockActions = savedBlockActions; + blockStack = savedBlockStack; + labelOffsets = savedLabelOffsets; + labelExpressions = savedLabelExpressions; + nextLabelId = savedNextLabelId; + operations = savedOperations; + operationArguments = savedOperationArguments; + operationLocations = savedOperationLocations; + state = savedState; + return ts.setTextRange(ts.createBlock(statements, body.multiLine), body); + } + function visitVariableStatement(node) { + if (node.transformFlags & 262144) { + transformAndEmitVariableDeclarationList(node.declarationList); + return undefined; + } + else { + if (ts.getEmitFlags(node) & 1048576) { + return node; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + var variables = ts.getInitializedVariables(node.declarationList); + if (variables.length === 0) { + return undefined; + } + return ts.setSourceMapRange(ts.createExpressionStatement(ts.inlineExpressions(ts.map(variables, transformInitializedVariable))), node); + } + } + function visitBinaryExpression(node) { + var assoc = ts.getExpressionAssociativity(node); + switch (assoc) { + case 0: + return visitLeftAssociativeBinaryExpression(node); + case 1: + return visitRightAssociativeBinaryExpression(node); + default: + return ts.Debug.assertNever(assoc); + } + } + function visitRightAssociativeBinaryExpression(node) { + var left = node.left, right = node.right; + if (containsYield(right)) { + var target = void 0; + switch (left.kind) { + case 194: + target = ts.updatePropertyAccess(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), left.name); + break; + case 195: + target = ts.updateElementAccess(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), cacheExpression(ts.visitNode(left.argumentExpression, visitor, ts.isExpression))); + break; + default: + target = ts.visitNode(left, visitor, ts.isExpression); + break; + } + var operator = node.operatorToken.kind; + if (ts.isCompoundAssignment(operator)) { + return ts.setTextRange(ts.createAssignment(target, ts.setTextRange(ts.createBinary(cacheExpression(target), ts.getNonAssignmentOperatorForCompoundAssignment(operator), ts.visitNode(right, visitor, ts.isExpression)), node)), node); + } + else { + return ts.updateBinary(node, target, ts.visitNode(right, visitor, ts.isExpression)); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitLeftAssociativeBinaryExpression(node) { + if (containsYield(node.right)) { + if (ts.isLogicalOperator(node.operatorToken.kind)) { + return visitLogicalBinaryExpression(node); + } + else if (node.operatorToken.kind === 27) { + return visitCommaExpression(node); + } + var clone_6 = ts.getMutableClone(node); + clone_6.left = cacheExpression(ts.visitNode(node.left, visitor, ts.isExpression)); + clone_6.right = ts.visitNode(node.right, visitor, ts.isExpression); + return clone_6; + } + return ts.visitEachChild(node, visitor, context); + } + function visitLogicalBinaryExpression(node) { + var resultLabel = defineLabel(); + var resultLocal = declareLocal(); + emitAssignment(resultLocal, ts.visitNode(node.left, visitor, ts.isExpression), node.left); + if (node.operatorToken.kind === 55) { + emitBreakWhenFalse(resultLabel, resultLocal, node.left); + } + else { + emitBreakWhenTrue(resultLabel, resultLocal, node.left); + } + emitAssignment(resultLocal, ts.visitNode(node.right, visitor, ts.isExpression), node.right); + markLabel(resultLabel); + return resultLocal; + } + function visitCommaExpression(node) { + var pendingExpressions = []; + visit(node.left); + visit(node.right); + return ts.inlineExpressions(pendingExpressions); + function visit(node) { + if (ts.isBinaryExpression(node) && node.operatorToken.kind === 27) { + visit(node.left); + visit(node.right); + } + else { + if (containsYield(node) && pendingExpressions.length > 0) { + emitWorker(1, [ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions))]); + pendingExpressions = []; + } + pendingExpressions.push(ts.visitNode(node, visitor, ts.isExpression)); + } + } + } + function visitConditionalExpression(node) { + if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) { + var whenFalseLabel = defineLabel(); + var resultLabel = defineLabel(); + var resultLocal = declareLocal(); + emitBreakWhenFalse(whenFalseLabel, ts.visitNode(node.condition, visitor, ts.isExpression), node.condition); + emitAssignment(resultLocal, ts.visitNode(node.whenTrue, visitor, ts.isExpression), node.whenTrue); + emitBreak(resultLabel); + markLabel(whenFalseLabel); + emitAssignment(resultLocal, ts.visitNode(node.whenFalse, visitor, ts.isExpression), node.whenFalse); + markLabel(resultLabel); + return resultLocal; + } + return ts.visitEachChild(node, visitor, context); + } + function visitYieldExpression(node) { + var resumeLabel = defineLabel(); + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + if (node.asteriskToken) { + var iterator = (ts.getEmitFlags(node.expression) & 8388608) === 0 + ? ts.createValuesHelper(context, expression, node) + : expression; + emitYieldStar(iterator, node); + } + else { + emitYield(expression, node); + } + markLabel(resumeLabel); + return createGeneratorResume(node); + } + function visitArrayLiteralExpression(node) { + return visitElements(node.elements, undefined, undefined, node.multiLine); + } + function visitElements(elements, leadingElement, location, multiLine) { + var numInitialElements = countInitialNodesWithoutYield(elements); + var temp; + if (numInitialElements > 0) { + temp = declareLocal(); + var initialElements = ts.visitNodes(elements, visitor, ts.isExpression, 0, numInitialElements); + emitAssignment(temp, ts.createArrayLiteral(leadingElement + ? __spreadArrays([leadingElement], initialElements) : initialElements)); + leadingElement = undefined; + } + var expressions = ts.reduceLeft(elements, reduceElement, [], numInitialElements); + return temp + ? ts.createArrayConcat(temp, [ts.createArrayLiteral(expressions, multiLine)]) + : ts.setTextRange(ts.createArrayLiteral(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine), location); + function reduceElement(expressions, element) { + if (containsYield(element) && expressions.length > 0) { + var hasAssignedTemp = temp !== undefined; + if (!temp) { + temp = declareLocal(); + } + emitAssignment(temp, hasAssignedTemp + ? ts.createArrayConcat(temp, [ts.createArrayLiteral(expressions, multiLine)]) + : ts.createArrayLiteral(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine)); + leadingElement = undefined; + expressions = []; + } + expressions.push(ts.visitNode(element, visitor, ts.isExpression)); + return expressions; + } + } + function visitObjectLiteralExpression(node) { + var properties = node.properties; + var multiLine = node.multiLine; + var numInitialProperties = countInitialNodesWithoutYield(properties); + var temp = declareLocal(); + emitAssignment(temp, ts.createObjectLiteral(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), multiLine)); + var expressions = ts.reduceLeft(properties, reduceProperty, [], numInitialProperties); + expressions.push(multiLine ? ts.startOnNewLine(ts.getMutableClone(temp)) : temp); + return ts.inlineExpressions(expressions); + function reduceProperty(expressions, property) { + if (containsYield(property) && expressions.length > 0) { + emitStatement(ts.createExpressionStatement(ts.inlineExpressions(expressions))); + expressions = []; + } + var expression = ts.createExpressionForObjectLiteralElementLike(node, property, temp); + var visited = ts.visitNode(expression, visitor, ts.isExpression); + if (visited) { + if (multiLine) { + ts.startOnNewLine(visited); + } + expressions.push(visited); + } + return expressions; + } + } + function visitElementAccessExpression(node) { + if (containsYield(node.argumentExpression)) { + var clone_7 = ts.getMutableClone(node); + clone_7.expression = cacheExpression(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)); + clone_7.argumentExpression = ts.visitNode(node.argumentExpression, visitor, ts.isExpression); + return clone_7; + } + return ts.visitEachChild(node, visitor, context); + } + function visitCallExpression(node) { + if (!ts.isImportCall(node) && ts.forEach(node.arguments, containsYield)) { + var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, true), target = _a.target, thisArg = _a.thisArg; + return ts.setOriginalNode(ts.createFunctionApply(cacheExpression(ts.visitNode(target, visitor, ts.isLeftHandSideExpression)), thisArg, visitElements(node.arguments), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitNewExpression(node) { + if (ts.forEach(node.arguments, containsYield)) { + var _a = ts.createCallBinding(ts.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + return ts.setOriginalNode(ts.setTextRange(ts.createNew(ts.createFunctionApply(cacheExpression(ts.visitNode(target, visitor, ts.isExpression)), thisArg, visitElements(node.arguments, ts.createVoidZero())), undefined, []), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitStatements(statements, start) { + if (start === void 0) { start = 0; } + var numStatements = statements.length; + for (var i = start; i < numStatements; i++) { + transformAndEmitStatement(statements[i]); + } + } + function transformAndEmitEmbeddedStatement(node) { + if (ts.isBlock(node)) { + transformAndEmitStatements(node.statements); + } + else { + transformAndEmitStatement(node); + } + } + function transformAndEmitStatement(node) { + var savedInStatementContainingYield = inStatementContainingYield; + if (!inStatementContainingYield) { + inStatementContainingYield = containsYield(node); + } + transformAndEmitStatementWorker(node); + inStatementContainingYield = savedInStatementContainingYield; + } + function transformAndEmitStatementWorker(node) { + switch (node.kind) { + case 223: + return transformAndEmitBlock(node); + case 226: + return transformAndEmitExpressionStatement(node); + case 227: + return transformAndEmitIfStatement(node); + case 228: + return transformAndEmitDoStatement(node); + case 229: + return transformAndEmitWhileStatement(node); + case 230: + return transformAndEmitForStatement(node); + case 231: + return transformAndEmitForInStatement(node); + case 233: + return transformAndEmitContinueStatement(node); + case 234: + return transformAndEmitBreakStatement(node); + case 235: + return transformAndEmitReturnStatement(node); + case 236: + return transformAndEmitWithStatement(node); + case 237: + return transformAndEmitSwitchStatement(node); + case 238: + return transformAndEmitLabeledStatement(node); + case 239: + return transformAndEmitThrowStatement(node); + case 240: + return transformAndEmitTryStatement(node); + default: + return emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitBlock(node) { + if (containsYield(node)) { + transformAndEmitStatements(node.statements); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitExpressionStatement(node) { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + function transformAndEmitVariableDeclarationList(node) { + for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + var name = ts.getSynthesizedClone(variable.name); + ts.setCommentRange(name, variable.name); + hoistVariableDeclaration(name); + } + var variables = ts.getInitializedVariables(node); + var numVariables = variables.length; + var variablesWritten = 0; + var pendingExpressions = []; + while (variablesWritten < numVariables) { + for (var i = variablesWritten; i < numVariables; i++) { + var variable = variables[i]; + if (containsYield(variable.initializer) && pendingExpressions.length > 0) { + break; + } + pendingExpressions.push(transformInitializedVariable(variable)); + } + if (pendingExpressions.length) { + emitStatement(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions))); + variablesWritten += pendingExpressions.length; + pendingExpressions = []; + } + } + return undefined; + } + function transformInitializedVariable(node) { + return ts.setSourceMapRange(ts.createAssignment(ts.setSourceMapRange(ts.getSynthesizedClone(node.name), node.name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node); + } + function transformAndEmitIfStatement(node) { + if (containsYield(node)) { + if (containsYield(node.thenStatement) || containsYield(node.elseStatement)) { + var endLabel = defineLabel(); + var elseLabel = node.elseStatement ? defineLabel() : undefined; + emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, ts.visitNode(node.expression, visitor, ts.isExpression), node.expression); + transformAndEmitEmbeddedStatement(node.thenStatement); + if (node.elseStatement) { + emitBreak(endLabel); + markLabel(elseLabel); + transformAndEmitEmbeddedStatement(node.elseStatement); + } + markLabel(endLabel); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitDoStatement(node) { + if (containsYield(node)) { + var conditionLabel = defineLabel(); + var loopLabel = defineLabel(); + beginLoopBlock(conditionLabel); + markLabel(loopLabel); + transformAndEmitEmbeddedStatement(node.statement); + markLabel(conditionLabel); + emitBreakWhenTrue(loopLabel, ts.visitNode(node.expression, visitor, ts.isExpression)); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitDoStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + node = ts.visitEachChild(node, visitor, context); + endLoopBlock(); + return node; + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformAndEmitWhileStatement(node) { + if (containsYield(node)) { + var loopLabel = defineLabel(); + var endLabel = beginLoopBlock(loopLabel); + markLabel(loopLabel); + emitBreakWhenFalse(endLabel, ts.visitNode(node.expression, visitor, ts.isExpression)); + transformAndEmitEmbeddedStatement(node.statement); + emitBreak(loopLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitWhileStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + node = ts.visitEachChild(node, visitor, context); + endLoopBlock(); + return node; + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformAndEmitForStatement(node) { + if (containsYield(node)) { + var conditionLabel = defineLabel(); + var incrementLabel = defineLabel(); + var endLabel = beginLoopBlock(incrementLabel); + if (node.initializer) { + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + transformAndEmitVariableDeclarationList(initializer); + } + else { + emitStatement(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(initializer, visitor, ts.isExpression)), initializer)); + } + } + markLabel(conditionLabel); + if (node.condition) { + emitBreakWhenFalse(endLabel, ts.visitNode(node.condition, visitor, ts.isExpression)); + } + transformAndEmitEmbeddedStatement(node.statement); + markLabel(incrementLabel); + if (node.incrementor) { + emitStatement(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), node.incrementor)); + } + emitBreak(conditionLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitForStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + } + var initializer = node.initializer; + if (initializer && ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + var variables = ts.getInitializedVariables(initializer); + node = ts.updateFor(node, variables.length > 0 + ? ts.inlineExpressions(ts.map(variables, transformInitializedVariable)) + : undefined, ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + } + else { + node = ts.visitEachChild(node, visitor, context); + } + if (inStatementContainingYield) { + endLoopBlock(); + } + return node; + } + function transformAndEmitForInStatement(node) { + if (containsYield(node)) { + var keysArray = declareLocal(); + var key = declareLocal(); + var keysIndex = ts.createLoopVariable(); + var initializer = node.initializer; + hoistVariableDeclaration(keysIndex); + emitAssignment(keysArray, ts.createArrayLiteral()); + emitStatement(ts.createForIn(key, ts.visitNode(node.expression, visitor, ts.isExpression), ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(keysArray, "push"), undefined, [key])))); + emitAssignment(keysIndex, ts.createLiteral(0)); + var conditionLabel = defineLabel(); + var incrementLabel = defineLabel(); + var endLabel = beginLoopBlock(incrementLabel); + markLabel(conditionLabel); + emitBreakWhenFalse(endLabel, ts.createLessThan(keysIndex, ts.createPropertyAccess(keysArray, "length"))); + var variable = void 0; + if (ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable_1 = _a[_i]; + hoistVariableDeclaration(variable_1.name); + } + variable = ts.getSynthesizedClone(initializer.declarations[0].name); + } + else { + variable = ts.visitNode(initializer, visitor, ts.isExpression); + ts.Debug.assert(ts.isLeftHandSideExpression(variable)); + } + emitAssignment(variable, ts.createElementAccess(keysArray, keysIndex)); + transformAndEmitEmbeddedStatement(node.statement); + markLabel(incrementLabel); + emitStatement(ts.createExpressionStatement(ts.createPostfixIncrement(keysIndex))); + emitBreak(conditionLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitForInStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + } + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + node = ts.updateForIn(node, initializer.declarations[0].name, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock)); + } + else { + node = ts.visitEachChild(node, visitor, context); + } + if (inStatementContainingYield) { + endLoopBlock(); + } + return node; + } + function transformAndEmitContinueStatement(node) { + var label = findContinueTarget(node.label ? ts.idText(node.label) : undefined); + if (label > 0) { + emitBreak(label, node); + } + else { + emitStatement(node); + } + } + function visitContinueStatement(node) { + if (inStatementContainingYield) { + var label = findContinueTarget(node.label && ts.idText(node.label)); + if (label > 0) { + return createInlineBreak(label, node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitBreakStatement(node) { + var label = findBreakTarget(node.label ? ts.idText(node.label) : undefined); + if (label > 0) { + emitBreak(label, node); + } + else { + emitStatement(node); + } + } + function visitBreakStatement(node) { + if (inStatementContainingYield) { + var label = findBreakTarget(node.label && ts.idText(node.label)); + if (label > 0) { + return createInlineBreak(label, node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitReturnStatement(node) { + emitReturn(ts.visitNode(node.expression, visitor, ts.isExpression), node); + } + function visitReturnStatement(node) { + return createInlineReturn(ts.visitNode(node.expression, visitor, ts.isExpression), node); + } + function transformAndEmitWithStatement(node) { + if (containsYield(node)) { + beginWithBlock(cacheExpression(ts.visitNode(node.expression, visitor, ts.isExpression))); + transformAndEmitEmbeddedStatement(node.statement); + endWithBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitSwitchStatement(node) { + if (containsYield(node.caseBlock)) { + var caseBlock = node.caseBlock; + var numClauses = caseBlock.clauses.length; + var endLabel = beginSwitchBlock(); + var expression = cacheExpression(ts.visitNode(node.expression, visitor, ts.isExpression)); + var clauseLabels = []; + var defaultClauseIndex = -1; + for (var i = 0; i < numClauses; i++) { + var clause = caseBlock.clauses[i]; + clauseLabels.push(defineLabel()); + if (clause.kind === 278 && defaultClauseIndex === -1) { + defaultClauseIndex = i; + } + } + var clausesWritten = 0; + var pendingClauses = []; + while (clausesWritten < numClauses) { + var defaultClausesSkipped = 0; + for (var i = clausesWritten; i < numClauses; i++) { + var clause = caseBlock.clauses[i]; + if (clause.kind === 277) { + if (containsYield(clause.expression) && pendingClauses.length > 0) { + break; + } + pendingClauses.push(ts.createCaseClause(ts.visitNode(clause.expression, visitor, ts.isExpression), [ + createInlineBreak(clauseLabels[i], clause.expression) + ])); + } + else { + defaultClausesSkipped++; + } + } + if (pendingClauses.length) { + emitStatement(ts.createSwitch(expression, ts.createCaseBlock(pendingClauses))); + clausesWritten += pendingClauses.length; + pendingClauses = []; + } + if (defaultClausesSkipped > 0) { + clausesWritten += defaultClausesSkipped; + defaultClausesSkipped = 0; + } + } + if (defaultClauseIndex >= 0) { + emitBreak(clauseLabels[defaultClauseIndex]); + } + else { + emitBreak(endLabel); + } + for (var i = 0; i < numClauses; i++) { + markLabel(clauseLabels[i]); + transformAndEmitStatements(caseBlock.clauses[i].statements); + } + endSwitchBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitSwitchStatement(node) { + if (inStatementContainingYield) { + beginScriptSwitchBlock(); + } + node = ts.visitEachChild(node, visitor, context); + if (inStatementContainingYield) { + endSwitchBlock(); + } + return node; + } + function transformAndEmitLabeledStatement(node) { + if (containsYield(node)) { + beginLabeledBlock(ts.idText(node.label)); + transformAndEmitEmbeddedStatement(node.statement); + endLabeledBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitLabeledStatement(node) { + if (inStatementContainingYield) { + beginScriptLabeledBlock(ts.idText(node.label)); + } + node = ts.visitEachChild(node, visitor, context); + if (inStatementContainingYield) { + endLabeledBlock(); + } + return node; + } + function transformAndEmitThrowStatement(node) { + emitThrow(ts.visitNode(node.expression, visitor, ts.isExpression), node); + } + function transformAndEmitTryStatement(node) { + if (containsYield(node)) { + beginExceptionBlock(); + transformAndEmitEmbeddedStatement(node.tryBlock); + if (node.catchClause) { + beginCatchBlock(node.catchClause.variableDeclaration); + transformAndEmitEmbeddedStatement(node.catchClause.block); + } + if (node.finallyBlock) { + beginFinallyBlock(); + transformAndEmitEmbeddedStatement(node.finallyBlock); + } + endExceptionBlock(); + } + else { + emitStatement(ts.visitEachChild(node, visitor, context)); + } + } + function containsYield(node) { + return !!node && (node.transformFlags & 262144) !== 0; + } + function countInitialNodesWithoutYield(nodes) { + var numNodes = nodes.length; + for (var i = 0; i < numNodes; i++) { + if (containsYield(nodes[i])) { + return i; + } + } + return -1; + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + if (ts.isIdentifier(node)) { + return substituteExpressionIdentifier(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + if (!ts.isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(ts.idText(node))) { + var original = ts.getOriginalNode(node); + if (ts.isIdentifier(original) && original.parent) { + var declaration = resolver.getReferencedValueDeclaration(original); + if (declaration) { + var name = renamedCatchVariableDeclarations[ts.getOriginalNodeId(declaration)]; + if (name) { + var clone_8 = ts.getMutableClone(name); + ts.setSourceMapRange(clone_8, node); + ts.setCommentRange(clone_8, node); + return clone_8; + } + } + } + } + return node; + } + function cacheExpression(node) { + if (ts.isGeneratedIdentifier(node) || ts.getEmitFlags(node) & 4096) { + return node; + } + var temp = ts.createTempVariable(hoistVariableDeclaration); + emitAssignment(temp, node, node); + return temp; + } + function declareLocal(name) { + var temp = name + ? ts.createUniqueName(name) + : ts.createTempVariable(undefined); + hoistVariableDeclaration(temp); + return temp; + } + function defineLabel() { + if (!labelOffsets) { + labelOffsets = []; + } + var label = nextLabelId; + nextLabelId++; + labelOffsets[label] = -1; + return label; + } + function markLabel(label) { + ts.Debug.assert(labelOffsets !== undefined, "No labels were defined."); + labelOffsets[label] = operations ? operations.length : 0; + } + function beginBlock(block) { + if (!blocks) { + blocks = []; + blockActions = []; + blockOffsets = []; + blockStack = []; + } + var index = blockActions.length; + blockActions[index] = 0; + blockOffsets[index] = operations ? operations.length : 0; + blocks[index] = block; + blockStack.push(block); + return index; + } + function endBlock() { + var block = peekBlock(); + if (block === undefined) + return ts.Debug.fail("beginBlock was never called."); + var index = blockActions.length; + blockActions[index] = 1; + blockOffsets[index] = operations ? operations.length : 0; + blocks[index] = block; + blockStack.pop(); + return block; + } + function peekBlock() { + return ts.lastOrUndefined(blockStack); + } + function peekBlockKind() { + var block = peekBlock(); + return block && block.kind; + } + function beginWithBlock(expression) { + var startLabel = defineLabel(); + var endLabel = defineLabel(); + markLabel(startLabel); + beginBlock({ + kind: 1, + expression: expression, + startLabel: startLabel, + endLabel: endLabel + }); + } + function endWithBlock() { + ts.Debug.assert(peekBlockKind() === 1); + var block = endBlock(); + markLabel(block.endLabel); + } + function beginExceptionBlock() { + var startLabel = defineLabel(); + var endLabel = defineLabel(); + markLabel(startLabel); + beginBlock({ + kind: 0, + state: 0, + startLabel: startLabel, + endLabel: endLabel + }); + emitNop(); + return endLabel; + } + function beginCatchBlock(variable) { + ts.Debug.assert(peekBlockKind() === 0); + var name; + if (ts.isGeneratedIdentifier(variable.name)) { + name = variable.name; + hoistVariableDeclaration(variable.name); + } + else { + var text = ts.idText(variable.name); + name = declareLocal(text); + if (!renamedCatchVariables) { + renamedCatchVariables = ts.createMap(); + renamedCatchVariableDeclarations = []; + context.enableSubstitution(75); + } + renamedCatchVariables.set(text, true); + renamedCatchVariableDeclarations[ts.getOriginalNodeId(variable)] = name; + } + var exception = peekBlock(); + ts.Debug.assert(exception.state < 1); + var endLabel = exception.endLabel; + emitBreak(endLabel); + var catchLabel = defineLabel(); + markLabel(catchLabel); + exception.state = 1; + exception.catchVariable = name; + exception.catchLabel = catchLabel; + emitAssignment(name, ts.createCall(ts.createPropertyAccess(state, "sent"), undefined, [])); + emitNop(); + } + function beginFinallyBlock() { + ts.Debug.assert(peekBlockKind() === 0); + var exception = peekBlock(); + ts.Debug.assert(exception.state < 2); + var endLabel = exception.endLabel; + emitBreak(endLabel); + var finallyLabel = defineLabel(); + markLabel(finallyLabel); + exception.state = 2; + exception.finallyLabel = finallyLabel; + } + function endExceptionBlock() { + ts.Debug.assert(peekBlockKind() === 0); + var exception = endBlock(); + var state = exception.state; + if (state < 2) { + emitBreak(exception.endLabel); + } + else { + emitEndfinally(); + } + markLabel(exception.endLabel); + emitNop(); + exception.state = 3; + } + function beginScriptLoopBlock() { + beginBlock({ + kind: 3, + isScript: true, + breakLabel: -1, + continueLabel: -1 + }); + } + function beginLoopBlock(continueLabel) { + var breakLabel = defineLabel(); + beginBlock({ + kind: 3, + isScript: false, + breakLabel: breakLabel, + continueLabel: continueLabel, + }); + return breakLabel; + } + function endLoopBlock() { + ts.Debug.assert(peekBlockKind() === 3); + var block = endBlock(); + var breakLabel = block.breakLabel; + if (!block.isScript) { + markLabel(breakLabel); + } + } + function beginScriptSwitchBlock() { + beginBlock({ + kind: 2, + isScript: true, + breakLabel: -1 + }); + } + function beginSwitchBlock() { + var breakLabel = defineLabel(); + beginBlock({ + kind: 2, + isScript: false, + breakLabel: breakLabel, + }); + return breakLabel; + } + function endSwitchBlock() { + ts.Debug.assert(peekBlockKind() === 2); + var block = endBlock(); + var breakLabel = block.breakLabel; + if (!block.isScript) { + markLabel(breakLabel); + } + } + function beginScriptLabeledBlock(labelText) { + beginBlock({ + kind: 4, + isScript: true, + labelText: labelText, + breakLabel: -1 + }); + } + function beginLabeledBlock(labelText) { + var breakLabel = defineLabel(); + beginBlock({ + kind: 4, + isScript: false, + labelText: labelText, + breakLabel: breakLabel + }); + } + function endLabeledBlock() { + ts.Debug.assert(peekBlockKind() === 4); + var block = endBlock(); + if (!block.isScript) { + markLabel(block.breakLabel); + } + } + function supportsUnlabeledBreak(block) { + return block.kind === 2 + || block.kind === 3; + } + function supportsLabeledBreakOrContinue(block) { + return block.kind === 4; + } + function supportsUnlabeledContinue(block) { + return block.kind === 3; + } + function hasImmediateContainingLabeledBlock(labelText, start) { + for (var j = start; j >= 0; j--) { + var containingBlock = blockStack[j]; + if (supportsLabeledBreakOrContinue(containingBlock)) { + if (containingBlock.labelText === labelText) { + return true; + } + } + else { + break; + } + } + return false; + } + function findBreakTarget(labelText) { + if (blockStack) { + if (labelText) { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsLabeledBreakOrContinue(block) && block.labelText === labelText) { + return block.breakLabel; + } + else if (supportsUnlabeledBreak(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) { + return block.breakLabel; + } + } + } + else { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledBreak(block)) { + return block.breakLabel; + } + } + } + } + return 0; + } + function findContinueTarget(labelText) { + if (blockStack) { + if (labelText) { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledContinue(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) { + return block.continueLabel; + } + } + } + else { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledContinue(block)) { + return block.continueLabel; + } + } + } + } + return 0; + } + function createLabel(label) { + if (label !== undefined && label > 0) { + if (labelExpressions === undefined) { + labelExpressions = []; + } + var expression = ts.createLiteral(-1); + if (labelExpressions[label] === undefined) { + labelExpressions[label] = [expression]; + } + else { + labelExpressions[label].push(expression); + } + return expression; + } + return ts.createOmittedExpression(); + } + function createInstruction(instruction) { + var literal = ts.createLiteral(instruction); + ts.addSyntheticTrailingComment(literal, 3, getInstructionName(instruction)); + return literal; + } + function createInlineBreak(label, location) { + ts.Debug.assertLessThan(0, label, "Invalid label"); + return ts.setTextRange(ts.createReturn(ts.createArrayLiteral([ + createInstruction(3), + createLabel(label) + ])), location); + } + function createInlineReturn(expression, location) { + return ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression + ? [createInstruction(2), expression] + : [createInstruction(2)])), location); + } + function createGeneratorResume(location) { + return ts.setTextRange(ts.createCall(ts.createPropertyAccess(state, "sent"), undefined, []), location); + } + function emitNop() { + emitWorker(0); + } + function emitStatement(node) { + if (node) { + emitWorker(1, [node]); + } + else { + emitNop(); + } + } + function emitAssignment(left, right, location) { + emitWorker(2, [left, right], location); + } + function emitBreak(label, location) { + emitWorker(3, [label], location); + } + function emitBreakWhenTrue(label, condition, location) { + emitWorker(4, [label, condition], location); + } + function emitBreakWhenFalse(label, condition, location) { + emitWorker(5, [label, condition], location); + } + function emitYieldStar(expression, location) { + emitWorker(7, [expression], location); + } + function emitYield(expression, location) { + emitWorker(6, [expression], location); + } + function emitReturn(expression, location) { + emitWorker(8, [expression], location); + } + function emitThrow(expression, location) { + emitWorker(9, [expression], location); + } + function emitEndfinally() { + emitWorker(10); + } + function emitWorker(code, args, location) { + if (operations === undefined) { + operations = []; + operationArguments = []; + operationLocations = []; + } + if (labelOffsets === undefined) { + markLabel(defineLabel()); + } + var operationIndex = operations.length; + operations[operationIndex] = code; + operationArguments[operationIndex] = args; + operationLocations[operationIndex] = location; + } + function build() { + blockIndex = 0; + labelNumber = 0; + labelNumbers = undefined; + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + clauses = undefined; + statements = undefined; + exceptionBlockStack = undefined; + currentExceptionBlock = undefined; + withBlockStack = undefined; + var buildResult = buildStatements(); + return createGeneratorHelper(context, ts.setEmitFlags(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, state)], undefined, ts.createBlock(buildResult, buildResult.length > 0)), 524288)); + } + function buildStatements() { + if (operations) { + for (var operationIndex = 0; operationIndex < operations.length; operationIndex++) { + writeOperation(operationIndex); + } + flushFinalLabel(operations.length); + } + else { + flushFinalLabel(0); + } + if (clauses) { + var labelExpression = ts.createPropertyAccess(state, "label"); + var switchStatement = ts.createSwitch(labelExpression, ts.createCaseBlock(clauses)); + return [ts.startOnNewLine(switchStatement)]; + } + if (statements) { + return statements; + } + return []; + } + function flushLabel() { + if (!statements) { + return; + } + appendLabel(!lastOperationWasAbrupt); + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + labelNumber++; + } + function flushFinalLabel(operationIndex) { + if (isFinalLabelReachable(operationIndex)) { + tryEnterLabel(operationIndex); + withBlockStack = undefined; + writeReturn(undefined, undefined); + } + if (statements && clauses) { + appendLabel(false); + } + updateLabelExpressions(); + } + function isFinalLabelReachable(operationIndex) { + if (!lastOperationWasCompletion) { + return true; + } + if (!labelOffsets || !labelExpressions) { + return false; + } + for (var label = 0; label < labelOffsets.length; label++) { + if (labelOffsets[label] === operationIndex && labelExpressions[label]) { + return true; + } + } + return false; + } + function appendLabel(markLabelEnd) { + if (!clauses) { + clauses = []; + } + if (statements) { + if (withBlockStack) { + for (var i = withBlockStack.length - 1; i >= 0; i--) { + var withBlock = withBlockStack[i]; + statements = [ts.createWith(withBlock.expression, ts.createBlock(statements))]; + } + } + if (currentExceptionBlock) { + var startLabel = currentExceptionBlock.startLabel, catchLabel = currentExceptionBlock.catchLabel, finallyLabel = currentExceptionBlock.finallyLabel, endLabel = currentExceptionBlock.endLabel; + statements.unshift(ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createPropertyAccess(state, "trys"), "push"), undefined, [ + ts.createArrayLiteral([ + createLabel(startLabel), + createLabel(catchLabel), + createLabel(finallyLabel), + createLabel(endLabel) + ]) + ]))); + currentExceptionBlock = undefined; + } + if (markLabelEnd) { + statements.push(ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(state, "label"), ts.createLiteral(labelNumber + 1)))); + } + } + clauses.push(ts.createCaseClause(ts.createLiteral(labelNumber), statements || [])); + statements = undefined; + } + function tryEnterLabel(operationIndex) { + if (!labelOffsets) { + return; + } + for (var label = 0; label < labelOffsets.length; label++) { + if (labelOffsets[label] === operationIndex) { + flushLabel(); + if (labelNumbers === undefined) { + labelNumbers = []; + } + if (labelNumbers[labelNumber] === undefined) { + labelNumbers[labelNumber] = [label]; + } + else { + labelNumbers[labelNumber].push(label); + } + } + } + } + function updateLabelExpressions() { + if (labelExpressions !== undefined && labelNumbers !== undefined) { + for (var labelNumber_1 = 0; labelNumber_1 < labelNumbers.length; labelNumber_1++) { + var labels = labelNumbers[labelNumber_1]; + if (labels !== undefined) { + for (var _i = 0, labels_1 = labels; _i < labels_1.length; _i++) { + var label = labels_1[_i]; + var expressions = labelExpressions[label]; + if (expressions !== undefined) { + for (var _a = 0, expressions_1 = expressions; _a < expressions_1.length; _a++) { + var expression = expressions_1[_a]; + expression.text = String(labelNumber_1); + } + } + } + } + } + } + } + function tryEnterOrLeaveBlock(operationIndex) { + if (blocks) { + for (; blockIndex < blockActions.length && blockOffsets[blockIndex] <= operationIndex; blockIndex++) { + var block = blocks[blockIndex]; + var blockAction = blockActions[blockIndex]; + switch (block.kind) { + case 0: + if (blockAction === 0) { + if (!exceptionBlockStack) { + exceptionBlockStack = []; + } + if (!statements) { + statements = []; + } + exceptionBlockStack.push(currentExceptionBlock); + currentExceptionBlock = block; + } + else if (blockAction === 1) { + currentExceptionBlock = exceptionBlockStack.pop(); + } + break; + case 1: + if (blockAction === 0) { + if (!withBlockStack) { + withBlockStack = []; + } + withBlockStack.push(block); + } + else if (blockAction === 1) { + withBlockStack.pop(); + } + break; + } + } + } + } + function writeOperation(operationIndex) { + tryEnterLabel(operationIndex); + tryEnterOrLeaveBlock(operationIndex); + if (lastOperationWasAbrupt) { + return; + } + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + var opcode = operations[operationIndex]; + if (opcode === 0) { + return; + } + else if (opcode === 10) { + return writeEndfinally(); + } + var args = operationArguments[operationIndex]; + if (opcode === 1) { + return writeStatement(args[0]); + } + var location = operationLocations[operationIndex]; + switch (opcode) { + case 2: + return writeAssign(args[0], args[1], location); + case 3: + return writeBreak(args[0], location); + case 4: + return writeBreakWhenTrue(args[0], args[1], location); + case 5: + return writeBreakWhenFalse(args[0], args[1], location); + case 6: + return writeYield(args[0], location); + case 7: + return writeYieldStar(args[0], location); + case 8: + return writeReturn(args[0], location); + case 9: + return writeThrow(args[0], location); + } + } + function writeStatement(statement) { + if (statement) { + if (!statements) { + statements = [statement]; + } + else { + statements.push(statement); + } + } + } + function writeAssign(left, right, operationLocation) { + writeStatement(ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(left, right)), operationLocation)); + } + function writeThrow(expression, operationLocation) { + lastOperationWasAbrupt = true; + lastOperationWasCompletion = true; + writeStatement(ts.setTextRange(ts.createThrow(expression), operationLocation)); + } + function writeReturn(expression, operationLocation) { + lastOperationWasAbrupt = true; + lastOperationWasCompletion = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression + ? [createInstruction(2), expression] + : [createInstruction(2)])), operationLocation), 384)); + } + function writeBreak(label, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([ + createInstruction(3), + createLabel(label) + ])), operationLocation), 384)); + } + function writeBreakWhenTrue(label, condition, operationLocation) { + writeStatement(ts.setEmitFlags(ts.createIf(condition, ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([ + createInstruction(3), + createLabel(label) + ])), operationLocation), 384)), 1)); + } + function writeBreakWhenFalse(label, condition, operationLocation) { + writeStatement(ts.setEmitFlags(ts.createIf(ts.createLogicalNot(condition), ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([ + createInstruction(3), + createLabel(label) + ])), operationLocation), 384)), 1)); + } + function writeYield(expression, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression + ? [createInstruction(4), expression] + : [createInstruction(4)])), operationLocation), 384)); + } + function writeYieldStar(expression, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([ + createInstruction(5), + expression + ])), operationLocation), 384)); + } + function writeEndfinally() { + lastOperationWasAbrupt = true; + writeStatement(ts.createReturn(ts.createArrayLiteral([ + createInstruction(7) + ]))); + } + } + ts.transformGenerators = transformGenerators; + function createGeneratorHelper(context, body) { + context.requestEmitHelper(ts.generatorHelper); + return ts.createCall(ts.getUnscopedHelperName("__generator"), undefined, [ts.createThis(), body]); + } + ts.generatorHelper = { + name: "typescript:generator", + importName: "__generator", + scoped: false, + priority: 6, + text: "\n var __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n };" + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformModule(context) { + function getTransformModuleDelegate(moduleKind) { + switch (moduleKind) { + case ts.ModuleKind.AMD: return transformAMDModule; + case ts.ModuleKind.UMD: return transformUMDModule; + default: return transformCommonJSModule; + } + } + var startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var host = context.getEmitHost(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.onEmitNode = onEmitNode; + context.enableSubstitution(75); + context.enableSubstitution(209); + context.enableSubstitution(207); + context.enableSubstitution(208); + context.enableSubstitution(282); + context.enableEmitNotification(290); + var moduleInfoMap = []; + var deferredExports = []; + var currentSourceFile; + var currentModuleInfo; + var noSubstitution; + var needUMDDynamicImportHelper; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile || + !(ts.isEffectiveExternalModule(node, compilerOptions) || + node.transformFlags & 2097152 || + (ts.isJsonSourceFile(node) && ts.hasJsonModuleEmitEnabled(compilerOptions) && (compilerOptions.out || compilerOptions.outFile)))) { + return node; + } + currentSourceFile = node; + currentModuleInfo = ts.collectExternalModuleInfo(node, resolver, compilerOptions); + moduleInfoMap[ts.getOriginalNodeId(node)] = currentModuleInfo; + var transformModule = getTransformModuleDelegate(moduleKind); + var updated = transformModule(node); + currentSourceFile = undefined; + currentModuleInfo = undefined; + needUMDDynamicImportHelper = false; + return ts.aggregateTransformFlags(updated); + } + function shouldEmitUnderscoreUnderscoreESModule() { + if (!currentModuleInfo.exportEquals && ts.isExternalModule(currentSourceFile)) { + return true; + } + return false; + } + function transformCommonJSModule(node) { + startLexicalEnvironment(); + var statements = []; + var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile)); + var statementOffset = ts.addPrologue(statements, node.statements, ensureUseStrict && !ts.isJsonSourceFile(node), sourceElementVisitor); + if (shouldEmitUnderscoreUnderscoreESModule()) { + ts.append(statements, createUnderscoreUnderscoreESModule()); + } + ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement)); + ts.addRange(statements, ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset)); + addExportEqualsIfNeeded(statements, false); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(statements), node.statements)); + if (currentModuleInfo.hasExportStarsToExportValues && !compilerOptions.importHelpers) { + ts.addEmitHelper(updated, exportStarHelper); + } + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + function transformAMDModule(node) { + var define = ts.createIdentifier("define"); + var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions); + var jsonSourceFile = ts.isJsonSourceFile(node) && node; + var _a = collectAsynchronousDependencies(node, true), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames; + var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([ + ts.createExpressionStatement(ts.createCall(define, undefined, __spreadArrays((moduleName ? [moduleName] : []), [ + ts.createArrayLiteral(jsonSourceFile ? ts.emptyArray : __spreadArrays([ + ts.createLiteral("require"), + ts.createLiteral("exports") + ], aliasedModuleNames, unaliasedModuleNames)), + jsonSourceFile ? + jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : ts.createObjectLiteral() : + ts.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([ + ts.createParameter(undefined, undefined, undefined, "require"), + ts.createParameter(undefined, undefined, undefined, "exports") + ], importAliasNames), undefined, transformAsynchronousModuleBody(node)) + ]))) + ]), node.statements)); + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + function transformUMDModule(node) { + var _a = collectAsynchronousDependencies(node, false), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames; + var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions); + var umdHeader = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, "factory")], undefined, ts.setTextRange(ts.createBlock([ + ts.createIf(ts.createLogicalAnd(ts.createTypeCheck(ts.createIdentifier("module"), "object"), ts.createTypeCheck(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), "object")), ts.createBlock([ + ts.createVariableStatement(undefined, [ + ts.createVariableDeclaration("v", undefined, ts.createCall(ts.createIdentifier("factory"), undefined, [ + ts.createIdentifier("require"), + ts.createIdentifier("exports") + ])) + ]), + ts.setEmitFlags(ts.createIf(ts.createStrictInequality(ts.createIdentifier("v"), ts.createIdentifier("undefined")), ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), ts.createIdentifier("v")))), 1) + ]), ts.createIf(ts.createLogicalAnd(ts.createTypeCheck(ts.createIdentifier("define"), "function"), ts.createPropertyAccess(ts.createIdentifier("define"), "amd")), ts.createBlock([ + ts.createExpressionStatement(ts.createCall(ts.createIdentifier("define"), undefined, __spreadArrays((moduleName ? [moduleName] : []), [ + ts.createArrayLiteral(__spreadArrays([ + ts.createLiteral("require"), + ts.createLiteral("exports") + ], aliasedModuleNames, unaliasedModuleNames)), + ts.createIdentifier("factory") + ]))) + ]))) + ], true), undefined)); + var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([ + ts.createExpressionStatement(ts.createCall(umdHeader, undefined, [ + ts.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([ + ts.createParameter(undefined, undefined, undefined, "require"), + ts.createParameter(undefined, undefined, undefined, "exports") + ], importAliasNames), undefined, transformAsynchronousModuleBody(node)) + ])) + ]), node.statements)); + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + function collectAsynchronousDependencies(node, includeNonAmdDependencies) { + var aliasedModuleNames = []; + var unaliasedModuleNames = []; + var importAliasNames = []; + for (var _i = 0, _a = node.amdDependencies; _i < _a.length; _i++) { + var amdDependency = _a[_i]; + if (amdDependency.name) { + aliasedModuleNames.push(ts.createLiteral(amdDependency.path)); + importAliasNames.push(ts.createParameter(undefined, undefined, undefined, amdDependency.name)); + } + else { + unaliasedModuleNames.push(ts.createLiteral(amdDependency.path)); + } + } + for (var _b = 0, _c = currentModuleInfo.externalImports; _b < _c.length; _b++) { + var importNode = _c[_b]; + var externalModuleName = ts.getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions); + var importAliasName = ts.getLocalNameForExternalImport(importNode, currentSourceFile); + if (externalModuleName) { + if (includeNonAmdDependencies && importAliasName) { + ts.setEmitFlags(importAliasName, 4); + aliasedModuleNames.push(externalModuleName); + importAliasNames.push(ts.createParameter(undefined, undefined, undefined, importAliasName)); + } + else { + unaliasedModuleNames.push(externalModuleName); + } + } + } + return { aliasedModuleNames: aliasedModuleNames, unaliasedModuleNames: unaliasedModuleNames, importAliasNames: importAliasNames }; + } + function getAMDImportExpressionForImport(node) { + if (ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node) || !ts.getExternalModuleNameLiteral(node, currentSourceFile, host, resolver, compilerOptions)) { + return undefined; + } + var name = ts.getLocalNameForExternalImport(node, currentSourceFile); + var expr = getHelperExpressionForImport(node, name); + if (expr === name) { + return undefined; + } + return ts.createExpressionStatement(ts.createAssignment(name, expr)); + } + function transformAsynchronousModuleBody(node) { + startLexicalEnvironment(); + var statements = []; + var statementOffset = ts.addPrologue(statements, node.statements, !compilerOptions.noImplicitUseStrict, sourceElementVisitor); + if (shouldEmitUnderscoreUnderscoreESModule()) { + ts.append(statements, createUnderscoreUnderscoreESModule()); + } + ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement)); + if (moduleKind === ts.ModuleKind.AMD) { + ts.addRange(statements, ts.mapDefined(currentModuleInfo.externalImports, getAMDImportExpressionForImport)); + } + ts.addRange(statements, ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset)); + addExportEqualsIfNeeded(statements, true); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var body = ts.createBlock(statements, true); + if (currentModuleInfo.hasExportStarsToExportValues && !compilerOptions.importHelpers) { + ts.addEmitHelper(body, exportStarHelper); + } + if (needUMDDynamicImportHelper) { + ts.addEmitHelper(body, dynamicImportUMDHelper); + } + return body; + } + function addExportEqualsIfNeeded(statements, emitAsReturn) { + if (currentModuleInfo.exportEquals) { + var expressionResult = ts.visitNode(currentModuleInfo.exportEquals.expression, moduleExpressionElementVisitor); + if (expressionResult) { + if (emitAsReturn) { + var statement = ts.createReturn(expressionResult); + ts.setTextRange(statement, currentModuleInfo.exportEquals); + ts.setEmitFlags(statement, 384 | 1536); + statements.push(statement); + } + else { + var statement = ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), expressionResult)); + ts.setTextRange(statement, currentModuleInfo.exportEquals); + ts.setEmitFlags(statement, 1536); + statements.push(statement); + } + } + } + } + function sourceElementVisitor(node) { + switch (node.kind) { + case 254: + return visitImportDeclaration(node); + case 253: + return visitImportEqualsDeclaration(node); + case 260: + return visitExportDeclaration(node); + case 259: + return visitExportAssignment(node); + case 225: + return visitVariableStatement(node); + case 244: + return visitFunctionDeclaration(node); + case 245: + return visitClassDeclaration(node); + case 327: + return visitMergeDeclarationMarker(node); + case 328: + return visitEndOfDeclarationMarker(node); + default: + return ts.visitEachChild(node, moduleExpressionElementVisitor, context); + } + } + function moduleExpressionElementVisitor(node) { + if (!(node.transformFlags & 2097152) && !(node.transformFlags & 1024)) { + return node; + } + if (ts.isImportCall(node)) { + return visitImportCallExpression(node); + } + else if (ts.isDestructuringAssignment(node)) { + return visitDestructuringAssignment(node); + } + else { + return ts.visitEachChild(node, moduleExpressionElementVisitor, context); + } + } + function destructuringNeedsFlattening(node) { + if (ts.isObjectLiteralExpression(node)) { + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var elem = _a[_i]; + switch (elem.kind) { + case 281: + if (destructuringNeedsFlattening(elem.initializer)) { + return true; + } + break; + case 282: + if (destructuringNeedsFlattening(elem.name)) { + return true; + } + break; + case 283: + if (destructuringNeedsFlattening(elem.expression)) { + return true; + } + break; + case 161: + case 163: + case 164: + return false; + default: ts.Debug.assertNever(elem, "Unhandled object member kind"); + } + } + } + else if (ts.isArrayLiteralExpression(node)) { + for (var _b = 0, _c = node.elements; _b < _c.length; _b++) { + var elem = _c[_b]; + if (ts.isSpreadElement(elem)) { + if (destructuringNeedsFlattening(elem.expression)) { + return true; + } + } + else if (destructuringNeedsFlattening(elem)) { + return true; + } + } + } + else if (ts.isIdentifier(node)) { + return ts.length(getExports(node)) > (ts.isExportName(node) ? 1 : 0); + } + return false; + } + function visitDestructuringAssignment(node) { + if (destructuringNeedsFlattening(node.left)) { + return ts.flattenDestructuringAssignment(node, moduleExpressionElementVisitor, context, 0, false, createAllExportExpressions); + } + return ts.visitEachChild(node, moduleExpressionElementVisitor, context); + } + function visitImportCallExpression(node) { + var argument = ts.visitNode(ts.firstOrUndefined(node.arguments), moduleExpressionElementVisitor); + var containsLexicalThis = !!(node.transformFlags & 4096); + switch (compilerOptions.module) { + case ts.ModuleKind.AMD: + return createImportCallExpressionAMD(argument, containsLexicalThis); + case ts.ModuleKind.UMD: + return createImportCallExpressionUMD(argument, containsLexicalThis); + case ts.ModuleKind.CommonJS: + default: + return createImportCallExpressionCommonJS(argument, containsLexicalThis); + } + } + function createImportCallExpressionUMD(arg, containsLexicalThis) { + needUMDDynamicImportHelper = true; + if (ts.isSimpleCopiableExpression(arg)) { + var argClone = ts.isGeneratedIdentifier(arg) ? arg : ts.isStringLiteral(arg) ? ts.createLiteral(arg) : ts.setEmitFlags(ts.setTextRange(ts.getSynthesizedClone(arg), arg), 1536); + return ts.createConditional(ts.createIdentifier("__syncRequire"), createImportCallExpressionCommonJS(arg, containsLexicalThis), createImportCallExpressionAMD(argClone, containsLexicalThis)); + } + else { + var temp = ts.createTempVariable(hoistVariableDeclaration); + return ts.createComma(ts.createAssignment(temp, arg), ts.createConditional(ts.createIdentifier("__syncRequire"), createImportCallExpressionCommonJS(temp, containsLexicalThis), createImportCallExpressionAMD(temp, containsLexicalThis))); + } + } + function createImportCallExpressionAMD(arg, containsLexicalThis) { + var resolve = ts.createUniqueName("resolve"); + var reject = ts.createUniqueName("reject"); + var parameters = [ + ts.createParameter(undefined, undefined, undefined, resolve), + ts.createParameter(undefined, undefined, undefined, reject) + ]; + var body = ts.createBlock([ + ts.createExpressionStatement(ts.createCall(ts.createIdentifier("require"), undefined, [ts.createArrayLiteral([arg || ts.createOmittedExpression()]), resolve, reject])) + ]); + var func; + if (languageVersion >= 2) { + func = ts.createArrowFunction(undefined, undefined, parameters, undefined, undefined, body); + } + else { + func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, parameters, undefined, body); + if (containsLexicalThis) { + ts.setEmitFlags(func, 8); + } + } + var promise = ts.createNew(ts.createIdentifier("Promise"), undefined, [func]); + if (compilerOptions.esModuleInterop) { + context.requestEmitHelper(ts.importStarHelper); + return ts.createCall(ts.createPropertyAccess(promise, ts.createIdentifier("then")), undefined, [ts.getUnscopedHelperName("__importStar")]); + } + return promise; + } + function createImportCallExpressionCommonJS(arg, containsLexicalThis) { + var promiseResolveCall = ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Promise"), "resolve"), undefined, []); + var requireCall = ts.createCall(ts.createIdentifier("require"), undefined, arg ? [arg] : []); + if (compilerOptions.esModuleInterop) { + context.requestEmitHelper(ts.importStarHelper); + requireCall = ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [requireCall]); + } + var func; + if (languageVersion >= 2) { + func = ts.createArrowFunction(undefined, undefined, [], undefined, undefined, requireCall); + } + else { + func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, ts.createBlock([ts.createReturn(requireCall)])); + if (containsLexicalThis) { + ts.setEmitFlags(func, 8); + } + } + return ts.createCall(ts.createPropertyAccess(promiseResolveCall, "then"), undefined, [func]); + } + function getHelperExpressionForExport(node, innerExpr) { + if (!compilerOptions.esModuleInterop || ts.getEmitFlags(node) & 67108864) { + return innerExpr; + } + if (ts.getExportNeedsImportStarHelper(node)) { + context.requestEmitHelper(ts.importStarHelper); + return ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [innerExpr]); + } + return innerExpr; + } + function getHelperExpressionForImport(node, innerExpr) { + if (!compilerOptions.esModuleInterop || ts.getEmitFlags(node) & 67108864) { + return innerExpr; + } + if (ts.getImportNeedsImportStarHelper(node)) { + context.requestEmitHelper(ts.importStarHelper); + return ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [innerExpr]); + } + if (ts.getImportNeedsImportDefaultHelper(node)) { + context.requestEmitHelper(ts.importDefaultHelper); + return ts.createCall(ts.getUnscopedHelperName("__importDefault"), undefined, [innerExpr]); + } + return innerExpr; + } + function visitImportDeclaration(node) { + var statements; + var namespaceDeclaration = ts.getNamespaceDeclarationNode(node); + if (moduleKind !== ts.ModuleKind.AMD) { + if (!node.importClause) { + return ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createRequireCall(node)), node), node); + } + else { + var variables = []; + if (namespaceDeclaration && !ts.isDefaultImport(node)) { + variables.push(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, getHelperExpressionForImport(node, createRequireCall(node)))); + } + else { + variables.push(ts.createVariableDeclaration(ts.getGeneratedNameForNode(node), undefined, getHelperExpressionForImport(node, createRequireCall(node)))); + if (namespaceDeclaration && ts.isDefaultImport(node)) { + variables.push(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, ts.getGeneratedNameForNode(node))); + } + } + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(variables, languageVersion >= 2 ? 2 : 0)), node), node)); + } + } + else if (namespaceDeclaration && ts.isDefaultImport(node)) { + statements = ts.append(statements, ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.setOriginalNode(ts.setTextRange(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, ts.getGeneratedNameForNode(node)), node), node) + ], languageVersion >= 2 ? 2 : 0))); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function createRequireCall(importNode) { + var moduleName = ts.getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions); + var args = []; + if (moduleName) { + args.push(moduleName); + } + return ts.createCall(ts.createIdentifier("require"), undefined, args); + } + function visitImportEqualsDeclaration(node) { + ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer."); + var statements; + if (moduleKind !== ts.ModuleKind.AMD) { + if (ts.hasModifier(node, 1)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(node.name, createRequireCall(node))), node), node)); + } + else { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(ts.getSynthesizedClone(node.name), undefined, createRequireCall(node)) + ], languageVersion >= 2 ? 2 : 0)), node), node)); + } + } + else { + if (ts.hasModifier(node, 1)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getExportName(node), ts.getLocalName(node))), node), node)); + } + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportEqualsDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitExportDeclaration(node) { + if (!node.moduleSpecifier) { + return undefined; + } + var generatedName = ts.getGeneratedNameForNode(node); + if (node.exportClause && ts.isNamedExports(node.exportClause)) { + var statements = []; + if (moduleKind !== ts.ModuleKind.AMD) { + statements.push(ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(generatedName, undefined, createRequireCall(node)) + ])), node), node)); + } + for (var _i = 0, _a = node.exportClause.elements; _i < _a.length; _i++) { + var specifier = _a[_i]; + var exportedValue = ts.createPropertyAccess(generatedName, specifier.propertyName || specifier.name); + statements.push(ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getExportName(specifier), exportedValue)), specifier), specifier)); + } + return ts.singleOrMany(statements); + } + else if (node.exportClause) { + var statements = []; + statements.push(ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getSynthesizedClone(node.exportClause.name), moduleKind !== ts.ModuleKind.AMD ? + getHelperExpressionForExport(node, createRequireCall(node)) : + ts.createIdentifier(ts.idText(node.exportClause.name)))), node), node)); + return ts.singleOrMany(statements); + } + else { + return ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportStarHelper(context, moduleKind !== ts.ModuleKind.AMD ? createRequireCall(node) : generatedName)), node), node); + } + } + function visitExportAssignment(node) { + if (node.isExportEquals) { + return undefined; + } + var statements; + var original = node.original; + if (original && hasAssociatedEndOfDeclarationMarker(original)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportStatement(deferredExports[id], ts.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true); + } + else { + statements = appendExportStatement(statements, ts.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true); + } + return ts.singleOrMany(statements); + } + function visitFunctionDeclaration(node) { + var statements; + if (ts.hasModifier(node, 1)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createFunctionDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, moduleExpressionElementVisitor), undefined, ts.visitEachChild(node.body, moduleExpressionElementVisitor, context)), node), node)); + } + else { + statements = ts.append(statements, ts.visitEachChild(node, moduleExpressionElementVisitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitClassDeclaration(node) { + var statements; + if (ts.hasModifier(node, 1)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createClassDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.heritageClauses, moduleExpressionElementVisitor), ts.visitNodes(node.members, moduleExpressionElementVisitor)), node), node)); + } + else { + statements = ts.append(statements, ts.visitEachChild(node, moduleExpressionElementVisitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitVariableStatement(node) { + var statements; + var variables; + var expressions; + if (ts.hasModifier(node, 1)) { + var modifiers = void 0; + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + if (ts.isIdentifier(variable.name) && ts.isLocalName(variable.name)) { + if (!modifiers) { + modifiers = ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier); + } + variables = ts.append(variables, variable); + } + else if (variable.initializer) { + expressions = ts.append(expressions, transformInitializedVariable(variable)); + } + } + if (variables) { + statements = ts.append(statements, ts.updateVariableStatement(node, modifiers, ts.updateVariableDeclarationList(node.declarationList, variables))); + } + if (expressions) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(expressions)), node), node)); + } + } + else { + statements = ts.append(statements, ts.visitEachChild(node, moduleExpressionElementVisitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node); + } + else { + statements = appendExportsOfVariableStatement(statements, node); + } + return ts.singleOrMany(statements); + } + function createAllExportExpressions(name, value, location) { + var exportedNames = getExports(name); + if (exportedNames) { + var expression = ts.isExportName(name) ? value : ts.createAssignment(name, value); + for (var _i = 0, exportedNames_1 = exportedNames; _i < exportedNames_1.length; _i++) { + var exportName = exportedNames_1[_i]; + ts.setEmitFlags(expression, 4); + expression = createExportExpression(exportName, expression, location); + } + return expression; + } + return ts.createAssignment(name, value); + } + function transformInitializedVariable(node) { + if (ts.isBindingPattern(node.name)) { + return ts.flattenDestructuringAssignment(ts.visitNode(node, moduleExpressionElementVisitor), undefined, context, 0, false, createAllExportExpressions); + } + else { + return ts.createAssignment(ts.setTextRange(ts.createPropertyAccess(ts.createIdentifier("exports"), node.name), node.name), ts.visitNode(node.initializer, moduleExpressionElementVisitor)); + } + } + function visitMergeDeclarationMarker(node) { + if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 225) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original); + } + return node; + } + function hasAssociatedEndOfDeclarationMarker(node) { + return (ts.getEmitFlags(node) & 4194304) !== 0; + } + function visitEndOfDeclarationMarker(node) { + var id = ts.getOriginalNodeId(node); + var statements = deferredExports[id]; + if (statements) { + delete deferredExports[id]; + return ts.append(statements, node); + } + return node; + } + function appendExportsOfImportDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + var importClause = decl.importClause; + if (!importClause) { + return statements; + } + if (importClause.name) { + statements = appendExportsOfDeclaration(statements, importClause); + } + var namedBindings = importClause.namedBindings; + if (namedBindings) { + switch (namedBindings.kind) { + case 256: + statements = appendExportsOfDeclaration(statements, namedBindings); + break; + case 257: + for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) { + var importBinding = _a[_i]; + statements = appendExportsOfDeclaration(statements, importBinding); + } + break; + } + } + return statements; + } + function appendExportsOfImportEqualsDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + return appendExportsOfDeclaration(statements, decl); + } + function appendExportsOfVariableStatement(statements, node) { + if (currentModuleInfo.exportEquals) { + return statements; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + statements = appendExportsOfBindingElement(statements, decl); + } + return statements; + } + function appendExportsOfBindingElement(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + statements = appendExportsOfBindingElement(statements, element); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + statements = appendExportsOfDeclaration(statements, decl); + } + return statements; + } + function appendExportsOfHoistedDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + if (ts.hasModifier(decl, 1)) { + var exportName = ts.hasModifier(decl, 512) ? ts.createIdentifier("default") : ts.getDeclarationName(decl); + statements = appendExportStatement(statements, exportName, ts.getLocalName(decl), decl); + } + if (decl.name) { + statements = appendExportsOfDeclaration(statements, decl); + } + return statements; + } + function appendExportsOfDeclaration(statements, decl) { + var name = ts.getDeclarationName(decl); + var exportSpecifiers = currentModuleInfo.exportSpecifiers.get(ts.idText(name)); + if (exportSpecifiers) { + for (var _i = 0, exportSpecifiers_1 = exportSpecifiers; _i < exportSpecifiers_1.length; _i++) { + var exportSpecifier = exportSpecifiers_1[_i]; + statements = appendExportStatement(statements, exportSpecifier.name, name, exportSpecifier.name); + } + } + return statements; + } + function appendExportStatement(statements, exportName, expression, location, allowComments) { + statements = ts.append(statements, createExportStatement(exportName, expression, location, allowComments)); + return statements; + } + function createUnderscoreUnderscoreESModule() { + var statement; + if (languageVersion === 0) { + statement = ts.createExpressionStatement(createExportExpression(ts.createIdentifier("__esModule"), ts.createLiteral(true))); + } + else { + statement = ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [ + ts.createIdentifier("exports"), + ts.createLiteral("__esModule"), + ts.createObjectLiteral([ + ts.createPropertyAssignment("value", ts.createLiteral(true)) + ]) + ])); + } + ts.setEmitFlags(statement, 1048576); + return statement; + } + function createExportStatement(name, value, location, allowComments) { + var statement = ts.setTextRange(ts.createExpressionStatement(createExportExpression(name, value)), location); + ts.startOnNewLine(statement); + if (!allowComments) { + ts.setEmitFlags(statement, 1536); + } + return statement; + } + function createExportExpression(name, value, location) { + return ts.setTextRange(ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.getSynthesizedClone(name)), value), location); + } + function modifierVisitor(node) { + switch (node.kind) { + case 89: + case 84: + return undefined; + } + return node; + } + function onEmitNode(hint, node, emitCallback) { + if (node.kind === 290) { + currentSourceFile = node; + currentModuleInfo = moduleInfoMap[ts.getOriginalNodeId(currentSourceFile)]; + noSubstitution = []; + previousOnEmitNode(hint, node, emitCallback); + currentSourceFile = undefined; + currentModuleInfo = undefined; + noSubstitution = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (node.id && noSubstitution[node.id]) { + return node; + } + if (hint === 1) { + return substituteExpression(node); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return substituteShorthandPropertyAssignment(node); + } + return node; + } + function substituteShorthandPropertyAssignment(node) { + var name = node.name; + var exportedOrImportedName = substituteExpressionIdentifier(name); + if (exportedOrImportedName !== name) { + if (node.objectAssignmentInitializer) { + var initializer = ts.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer); + return ts.setTextRange(ts.createPropertyAssignment(name, initializer), node); + } + return ts.setTextRange(ts.createPropertyAssignment(name, exportedOrImportedName), node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 75: + return substituteExpressionIdentifier(node); + case 209: + return substituteBinaryExpression(node); + case 208: + case 207: + return substituteUnaryExpression(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + if (ts.getEmitFlags(node) & 4096) { + var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); + if (externalHelpersModuleName) { + return ts.createPropertyAccess(externalHelpersModuleName, node); + } + return node; + } + if (!ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) { + var exportContainer = resolver.getReferencedExportContainer(node, ts.isExportName(node)); + if (exportContainer && exportContainer.kind === 290) { + return ts.setTextRange(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.getSynthesizedClone(node)), node); + } + var importDeclaration = resolver.getReferencedImportDeclaration(node); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default")), node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + var name = importDeclaration.propertyName || importDeclaration.name; + return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(name)), node); + } + } + } + return node; + } + function substituteBinaryExpression(node) { + if (ts.isAssignmentOperator(node.operatorToken.kind) + && ts.isIdentifier(node.left) + && !ts.isGeneratedIdentifier(node.left) + && !ts.isLocalName(node.left) + && !ts.isDeclarationNameOfEnumOrNamespace(node.left)) { + var exportedNames = getExports(node.left); + if (exportedNames) { + var expression = node; + for (var _i = 0, exportedNames_2 = exportedNames; _i < exportedNames_2.length; _i++) { + var exportName = exportedNames_2[_i]; + noSubstitution[ts.getNodeId(expression)] = true; + expression = createExportExpression(exportName, expression, node); + } + return expression; + } + } + return node; + } + function substituteUnaryExpression(node) { + if ((node.operator === 45 || node.operator === 46) + && ts.isIdentifier(node.operand) + && !ts.isGeneratedIdentifier(node.operand) + && !ts.isLocalName(node.operand) + && !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) { + var exportedNames = getExports(node.operand); + if (exportedNames) { + var expression = node.kind === 208 + ? ts.setTextRange(ts.createBinary(node.operand, ts.createToken(node.operator === 45 ? 63 : 64), ts.createLiteral(1)), node) + : node; + for (var _i = 0, exportedNames_3 = exportedNames; _i < exportedNames_3.length; _i++) { + var exportName = exportedNames_3[_i]; + noSubstitution[ts.getNodeId(expression)] = true; + expression = createExportExpression(exportName, expression); + } + return expression; + } + } + return node; + } + function getExports(name) { + if (!ts.isGeneratedIdentifier(name)) { + var valueDeclaration = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (valueDeclaration) { + return currentModuleInfo + && currentModuleInfo.exportedBindings[ts.getOriginalNodeId(valueDeclaration)]; + } + } + } + } + ts.transformModule = transformModule; + var exportStarHelper = { + name: "typescript:export-star", + scoped: true, + text: "\n function __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n }" + }; + function createExportStarHelper(context, module) { + var compilerOptions = context.getCompilerOptions(); + return compilerOptions.importHelpers + ? ts.createCall(ts.getUnscopedHelperName("__exportStar"), undefined, [module, ts.createIdentifier("exports")]) + : ts.createCall(ts.createIdentifier("__export"), undefined, [module]); + } + var dynamicImportUMDHelper = { + name: "typescript:dynamicimport-sync-require", + scoped: true, + text: "\n var __syncRequire = typeof module === \"object\" && typeof module.exports === \"object\";" + }; + ts.importStarHelper = { + name: "typescript:commonjsimportstar", + importName: "__importStar", + scoped: false, + text: "\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n result[\"default\"] = mod;\n return result;\n};" + }; + ts.importDefaultHelper = { + name: "typescript:commonjsimportdefault", + importName: "__importDefault", + scoped: false, + text: "\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};" + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformSystemModule(context) { + var startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var host = context.getEmitHost(); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.onEmitNode = onEmitNode; + context.enableSubstitution(75); + context.enableSubstitution(282); + context.enableSubstitution(209); + context.enableSubstitution(207); + context.enableSubstitution(208); + context.enableSubstitution(219); + context.enableEmitNotification(290); + var moduleInfoMap = []; + var deferredExports = []; + var exportFunctionsMap = []; + var noSubstitutionMap = []; + var contextObjectMap = []; + var currentSourceFile; + var moduleInfo; + var exportFunction; + var contextObject; + var hoistedStatements; + var enclosingBlockScopedContainer; + var noSubstitution; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile || !(ts.isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 2097152)) { + return node; + } + var id = ts.getOriginalNodeId(node); + currentSourceFile = node; + enclosingBlockScopedContainer = node; + moduleInfo = moduleInfoMap[id] = ts.collectExternalModuleInfo(node, resolver, compilerOptions); + exportFunction = ts.createUniqueName("exports"); + exportFunctionsMap[id] = exportFunction; + contextObject = contextObjectMap[id] = ts.createUniqueName("context"); + var dependencyGroups = collectDependencyGroups(moduleInfo.externalImports); + var moduleBodyBlock = createSystemModuleBody(node, dependencyGroups); + var moduleBodyFunction = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ + ts.createParameter(undefined, undefined, undefined, exportFunction), + ts.createParameter(undefined, undefined, undefined, contextObject) + ], undefined, moduleBodyBlock); + var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions); + var dependencies = ts.createArrayLiteral(ts.map(dependencyGroups, function (dependencyGroup) { return dependencyGroup.name; })); + var updated = ts.setEmitFlags(ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([ + ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("System"), "register"), undefined, moduleName + ? [moduleName, dependencies, moduleBodyFunction] + : [dependencies, moduleBodyFunction])) + ]), node.statements)), 1024); + if (!(compilerOptions.outFile || compilerOptions.out)) { + ts.moveEmitHelpers(updated, moduleBodyBlock, function (helper) { return !helper.scoped; }); + } + if (noSubstitution) { + noSubstitutionMap[id] = noSubstitution; + noSubstitution = undefined; + } + currentSourceFile = undefined; + moduleInfo = undefined; + exportFunction = undefined; + contextObject = undefined; + hoistedStatements = undefined; + enclosingBlockScopedContainer = undefined; + return ts.aggregateTransformFlags(updated); + } + function collectDependencyGroups(externalImports) { + var groupIndices = ts.createMap(); + var dependencyGroups = []; + for (var _i = 0, externalImports_1 = externalImports; _i < externalImports_1.length; _i++) { + var externalImport = externalImports_1[_i]; + var externalModuleName = ts.getExternalModuleNameLiteral(externalImport, currentSourceFile, host, resolver, compilerOptions); + if (externalModuleName) { + var text = externalModuleName.text; + var groupIndex = groupIndices.get(text); + if (groupIndex !== undefined) { + dependencyGroups[groupIndex].externalImports.push(externalImport); + } + else { + groupIndices.set(text, dependencyGroups.length); + dependencyGroups.push({ + name: externalModuleName, + externalImports: [externalImport] + }); + } + } + } + return dependencyGroups; + } + function createSystemModuleBody(node, dependencyGroups) { + var statements = []; + startLexicalEnvironment(); + var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile)); + var statementOffset = ts.addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor); + statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration("__moduleName", undefined, ts.createLogicalAnd(contextObject, ts.createPropertyAccess(contextObject, "id"))) + ]))); + ts.visitNode(moduleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement); + var executeStatements = ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset); + ts.addRange(statements, hoistedStatements); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var exportStarFunction = addExportStarIfNeeded(statements); + var modifiers = node.transformFlags & 524288 ? + ts.createModifiersFromModifierFlags(256) : + undefined; + var moduleObject = ts.createObjectLiteral([ + ts.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)), + ts.createPropertyAssignment("execute", ts.createFunctionExpression(modifiers, undefined, undefined, undefined, [], undefined, ts.createBlock(executeStatements, true))) + ]); + moduleObject.multiLine = true; + statements.push(ts.createReturn(moduleObject)); + return ts.createBlock(statements, true); + } + function addExportStarIfNeeded(statements) { + if (!moduleInfo.hasExportStarsToExportValues) { + return; + } + if (!moduleInfo.exportedNames && moduleInfo.exportSpecifiers.size === 0) { + var hasExportDeclarationWithExportClause = false; + for (var _i = 0, _a = moduleInfo.externalImports; _i < _a.length; _i++) { + var externalImport = _a[_i]; + if (externalImport.kind === 260 && externalImport.exportClause) { + hasExportDeclarationWithExportClause = true; + break; + } + } + if (!hasExportDeclarationWithExportClause) { + var exportStarFunction_1 = createExportStarFunction(undefined); + statements.push(exportStarFunction_1); + return exportStarFunction_1.name; + } + } + var exportedNames = []; + if (moduleInfo.exportedNames) { + for (var _b = 0, _c = moduleInfo.exportedNames; _b < _c.length; _b++) { + var exportedLocalName = _c[_b]; + if (exportedLocalName.escapedText === "default") { + continue; + } + exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(exportedLocalName), ts.createTrue())); + } + } + for (var _d = 0, _e = moduleInfo.externalImports; _d < _e.length; _d++) { + var externalImport = _e[_d]; + if (externalImport.kind !== 260) { + continue; + } + if (!externalImport.exportClause) { + continue; + } + if (ts.isNamedExports(externalImport.exportClause)) { + for (var _f = 0, _g = externalImport.exportClause.elements; _f < _g.length; _f++) { + var element = _g[_f]; + exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(element.name || element.propertyName)), ts.createTrue())); + } + } + else { + exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(externalImport.exportClause.name)), ts.createTrue())); + } + } + var exportedNamesStorageRef = ts.createUniqueName("exportedNames"); + statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(exportedNamesStorageRef, undefined, ts.createObjectLiteral(exportedNames, true)) + ]))); + var exportStarFunction = createExportStarFunction(exportedNamesStorageRef); + statements.push(exportStarFunction); + return exportStarFunction.name; + } + function createExportStarFunction(localNames) { + var exportStarFunction = ts.createUniqueName("exportStar"); + var m = ts.createIdentifier("m"); + var n = ts.createIdentifier("n"); + var exports = ts.createIdentifier("exports"); + var condition = ts.createStrictInequality(n, ts.createLiteral("default")); + if (localNames) { + condition = ts.createLogicalAnd(condition, ts.createLogicalNot(ts.createCall(ts.createPropertyAccess(localNames, "hasOwnProperty"), undefined, [n]))); + } + return ts.createFunctionDeclaration(undefined, undefined, undefined, exportStarFunction, undefined, [ts.createParameter(undefined, undefined, undefined, m)], undefined, ts.createBlock([ + ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ + ts.createVariableDeclaration(exports, undefined, ts.createObjectLiteral([])) + ])), + ts.createForIn(ts.createVariableDeclarationList([ + ts.createVariableDeclaration(n, undefined) + ]), m, ts.createBlock([ + ts.setEmitFlags(ts.createIf(condition, ts.createExpressionStatement(ts.createAssignment(ts.createElementAccess(exports, n), ts.createElementAccess(m, n)))), 1) + ])), + ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [exports])) + ], true)); + } + function createSettersArray(exportStarFunction, dependencyGroups) { + var setters = []; + for (var _i = 0, dependencyGroups_1 = dependencyGroups; _i < dependencyGroups_1.length; _i++) { + var group_2 = dependencyGroups_1[_i]; + var localName = ts.forEach(group_2.externalImports, function (i) { return ts.getLocalNameForExternalImport(i, currentSourceFile); }); + var parameterName = localName ? ts.getGeneratedNameForNode(localName) : ts.createUniqueName(""); + var statements = []; + for (var _a = 0, _b = group_2.externalImports; _a < _b.length; _a++) { + var entry = _b[_a]; + var importVariableName = ts.getLocalNameForExternalImport(entry, currentSourceFile); + switch (entry.kind) { + case 254: + if (!entry.importClause) { + break; + } + case 253: + ts.Debug.assert(importVariableName !== undefined); + statements.push(ts.createExpressionStatement(ts.createAssignment(importVariableName, parameterName))); + break; + case 260: + ts.Debug.assert(importVariableName !== undefined); + if (entry.exportClause) { + if (ts.isNamedExports(entry.exportClause)) { + var properties = []; + for (var _c = 0, _d = entry.exportClause.elements; _c < _d.length; _c++) { + var e = _d[_c]; + properties.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(e.name)), ts.createElementAccess(parameterName, ts.createLiteral(ts.idText(e.propertyName || e.name))))); + } + statements.push(ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [ts.createObjectLiteral(properties, true)]))); + } + else { + statements.push(ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [ + ts.createLiteral(ts.idText(entry.exportClause.name)), + parameterName + ]))); + } + } + else { + statements.push(ts.createExpressionStatement(ts.createCall(exportStarFunction, undefined, [parameterName]))); + } + break; + } + } + setters.push(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, ts.createBlock(statements, true))); + } + return ts.createArrayLiteral(setters, true); + } + function sourceElementVisitor(node) { + switch (node.kind) { + case 254: + return visitImportDeclaration(node); + case 253: + return visitImportEqualsDeclaration(node); + case 260: + return visitExportDeclaration(node); + case 259: + return visitExportAssignment(node); + default: + return nestedElementVisitor(node); + } + } + function visitImportDeclaration(node) { + var statements; + if (node.importClause) { + hoistVariableDeclaration(ts.getLocalNameForExternalImport(node, currentSourceFile)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitExportDeclaration(node) { + ts.Debug.assertDefined(node); + return undefined; + } + function visitImportEqualsDeclaration(node) { + ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer."); + var statements; + hoistVariableDeclaration(ts.getLocalNameForExternalImport(node, currentSourceFile)); + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportEqualsDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitExportAssignment(node) { + if (node.isExportEquals) { + return undefined; + } + var expression = ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression); + var original = node.original; + if (original && hasAssociatedEndOfDeclarationMarker(original)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportStatement(deferredExports[id], ts.createIdentifier("default"), expression, true); + } + else { + return createExportStatement(ts.createIdentifier("default"), expression, true); + } + } + function visitFunctionDeclaration(node) { + if (ts.hasModifier(node, 1)) { + hoistedStatements = ts.append(hoistedStatements, ts.updateFunctionDeclaration(node, node.decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, destructuringAndImportCallVisitor, ts.isParameterDeclaration), undefined, ts.visitNode(node.body, destructuringAndImportCallVisitor, ts.isBlock))); + } + else { + hoistedStatements = ts.append(hoistedStatements, ts.visitEachChild(node, destructuringAndImportCallVisitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node); + } + return undefined; + } + function visitClassDeclaration(node) { + var statements; + var name = ts.getLocalName(node); + hoistVariableDeclaration(name); + statements = ts.append(statements, ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(name, ts.setTextRange(ts.createClassExpression(undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, destructuringAndImportCallVisitor, ts.isHeritageClause), ts.visitNodes(node.members, destructuringAndImportCallVisitor, ts.isClassElement)), node))), node)); + if (hasAssociatedEndOfDeclarationMarker(node)) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitVariableStatement(node) { + if (!shouldHoistVariableDeclarationList(node.declarationList)) { + return ts.visitNode(node, destructuringAndImportCallVisitor, ts.isStatement); + } + var expressions; + var isExportedDeclaration = ts.hasModifier(node, 1); + var isMarkedDeclaration = hasAssociatedEndOfDeclarationMarker(node); + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + if (variable.initializer) { + expressions = ts.append(expressions, transformInitializedVariable(variable, isExportedDeclaration && !isMarkedDeclaration)); + } + else { + hoistBindingElement(variable); + } + } + var statements; + if (expressions) { + statements = ts.append(statements, ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(expressions)), node)); + } + if (isMarkedDeclaration) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration); + } + else { + statements = appendExportsOfVariableStatement(statements, node, false); + } + return ts.singleOrMany(statements); + } + function hoistBindingElement(node) { + if (ts.isBindingPattern(node.name)) { + for (var _i = 0, _a = node.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + hoistBindingElement(element); + } + } + } + else { + hoistVariableDeclaration(ts.getSynthesizedClone(node.name)); + } + } + function shouldHoistVariableDeclarationList(node) { + return (ts.getEmitFlags(node) & 2097152) === 0 + && (enclosingBlockScopedContainer.kind === 290 + || (ts.getOriginalNode(node).flags & 3) === 0); + } + function transformInitializedVariable(node, isExportedDeclaration) { + var createAssignment = isExportedDeclaration ? createExportedVariableAssignment : createNonExportedVariableAssignment; + return ts.isBindingPattern(node.name) + ? ts.flattenDestructuringAssignment(node, destructuringAndImportCallVisitor, context, 0, false, createAssignment) + : node.initializer ? createAssignment(node.name, ts.visitNode(node.initializer, destructuringAndImportCallVisitor, ts.isExpression)) : node.name; + } + function createExportedVariableAssignment(name, value, location) { + return createVariableAssignment(name, value, location, true); + } + function createNonExportedVariableAssignment(name, value, location) { + return createVariableAssignment(name, value, location, false); + } + function createVariableAssignment(name, value, location, isExportedDeclaration) { + hoistVariableDeclaration(ts.getSynthesizedClone(name)); + return isExportedDeclaration + ? createExportExpression(name, preventSubstitution(ts.setTextRange(ts.createAssignment(name, value), location))) + : preventSubstitution(ts.setTextRange(ts.createAssignment(name, value), location)); + } + function visitMergeDeclarationMarker(node) { + if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 225) { + var id = ts.getOriginalNodeId(node); + var isExportedDeclaration = ts.hasModifier(node.original, 1); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original, isExportedDeclaration); + } + return node; + } + function hasAssociatedEndOfDeclarationMarker(node) { + return (ts.getEmitFlags(node) & 4194304) !== 0; + } + function visitEndOfDeclarationMarker(node) { + var id = ts.getOriginalNodeId(node); + var statements = deferredExports[id]; + if (statements) { + delete deferredExports[id]; + return ts.append(statements, node); + } + else { + var original = ts.getOriginalNode(node); + if (ts.isModuleOrEnumDeclaration(original)) { + return ts.append(appendExportsOfDeclaration(statements, original), node); + } + } + return node; + } + function appendExportsOfImportDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + var importClause = decl.importClause; + if (!importClause) { + return statements; + } + if (importClause.name) { + statements = appendExportsOfDeclaration(statements, importClause); + } + var namedBindings = importClause.namedBindings; + if (namedBindings) { + switch (namedBindings.kind) { + case 256: + statements = appendExportsOfDeclaration(statements, namedBindings); + break; + case 257: + for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) { + var importBinding = _a[_i]; + statements = appendExportsOfDeclaration(statements, importBinding); + } + break; + } + } + return statements; + } + function appendExportsOfImportEqualsDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + return appendExportsOfDeclaration(statements, decl); + } + function appendExportsOfVariableStatement(statements, node, exportSelf) { + if (moduleInfo.exportEquals) { + return statements; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.initializer || exportSelf) { + statements = appendExportsOfBindingElement(statements, decl, exportSelf); + } + } + return statements; + } + function appendExportsOfBindingElement(statements, decl, exportSelf) { + if (moduleInfo.exportEquals) { + return statements; + } + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + statements = appendExportsOfBindingElement(statements, element, exportSelf); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + var excludeName = void 0; + if (exportSelf) { + statements = appendExportStatement(statements, decl.name, ts.getLocalName(decl)); + excludeName = ts.idText(decl.name); + } + statements = appendExportsOfDeclaration(statements, decl, excludeName); + } + return statements; + } + function appendExportsOfHoistedDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + var excludeName; + if (ts.hasModifier(decl, 1)) { + var exportName = ts.hasModifier(decl, 512) ? ts.createLiteral("default") : decl.name; + statements = appendExportStatement(statements, exportName, ts.getLocalName(decl)); + excludeName = ts.getTextOfIdentifierOrLiteral(exportName); + } + if (decl.name) { + statements = appendExportsOfDeclaration(statements, decl, excludeName); + } + return statements; + } + function appendExportsOfDeclaration(statements, decl, excludeName) { + if (moduleInfo.exportEquals) { + return statements; + } + var name = ts.getDeclarationName(decl); + var exportSpecifiers = moduleInfo.exportSpecifiers.get(ts.idText(name)); + if (exportSpecifiers) { + for (var _i = 0, exportSpecifiers_2 = exportSpecifiers; _i < exportSpecifiers_2.length; _i++) { + var exportSpecifier = exportSpecifiers_2[_i]; + if (exportSpecifier.name.escapedText !== excludeName) { + statements = appendExportStatement(statements, exportSpecifier.name, name); + } + } + } + return statements; + } + function appendExportStatement(statements, exportName, expression, allowComments) { + statements = ts.append(statements, createExportStatement(exportName, expression, allowComments)); + return statements; + } + function createExportStatement(name, value, allowComments) { + var statement = ts.createExpressionStatement(createExportExpression(name, value)); + ts.startOnNewLine(statement); + if (!allowComments) { + ts.setEmitFlags(statement, 1536); + } + return statement; + } + function createExportExpression(name, value) { + var exportName = ts.isIdentifier(name) ? ts.createLiteral(name) : name; + ts.setEmitFlags(value, ts.getEmitFlags(value) | 1536); + return ts.setCommentRange(ts.createCall(exportFunction, undefined, [exportName, value]), value); + } + function nestedElementVisitor(node) { + switch (node.kind) { + case 225: + return visitVariableStatement(node); + case 244: + return visitFunctionDeclaration(node); + case 245: + return visitClassDeclaration(node); + case 230: + return visitForStatement(node); + case 231: + return visitForInStatement(node); + case 232: + return visitForOfStatement(node); + case 228: + return visitDoStatement(node); + case 229: + return visitWhileStatement(node); + case 238: + return visitLabeledStatement(node); + case 236: + return visitWithStatement(node); + case 237: + return visitSwitchStatement(node); + case 251: + return visitCaseBlock(node); + case 277: + return visitCaseClause(node); + case 278: + return visitDefaultClause(node); + case 240: + return visitTryStatement(node); + case 280: + return visitCatchClause(node); + case 223: + return visitBlock(node); + case 327: + return visitMergeDeclarationMarker(node); + case 328: + return visitEndOfDeclarationMarker(node); + default: + return destructuringAndImportCallVisitor(node); + } + } + function visitForStatement(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.updateFor(node, node.initializer && visitForInitializer(node.initializer), ts.visitNode(node.condition, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.incrementor, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function visitForInStatement(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.updateForIn(node, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function visitForOfStatement(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.updateForOf(node, node.awaitModifier, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function shouldHoistForInitializer(node) { + return ts.isVariableDeclarationList(node) + && shouldHoistVariableDeclarationList(node); + } + function visitForInitializer(node) { + if (shouldHoistForInitializer(node)) { + var expressions = void 0; + for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + expressions = ts.append(expressions, transformInitializedVariable(variable, false)); + if (!variable.initializer) { + hoistBindingElement(variable); + } + } + return expressions ? ts.inlineExpressions(expressions) : ts.createOmittedExpression(); + } + else { + return ts.visitEachChild(node, nestedElementVisitor, context); + } + } + function visitDoStatement(node) { + return ts.updateDo(node, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression)); + } + function visitWhileStatement(node) { + return ts.updateWhile(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitLabeledStatement(node) { + return ts.updateLabel(node, node.label, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitWithStatement(node) { + return ts.updateWith(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock)); + } + function visitSwitchStatement(node) { + return ts.updateSwitch(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.caseBlock, nestedElementVisitor, ts.isCaseBlock)); + } + function visitCaseBlock(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.updateCaseBlock(node, ts.visitNodes(node.clauses, nestedElementVisitor, ts.isCaseOrDefaultClause)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function visitCaseClause(node) { + return ts.updateCaseClause(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNodes(node.statements, nestedElementVisitor, ts.isStatement)); + } + function visitDefaultClause(node) { + return ts.visitEachChild(node, nestedElementVisitor, context); + } + function visitTryStatement(node) { + return ts.visitEachChild(node, nestedElementVisitor, context); + } + function visitCatchClause(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.updateCatchClause(node, node.variableDeclaration, ts.visitNode(node.block, nestedElementVisitor, ts.isBlock)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function visitBlock(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.visitEachChild(node, nestedElementVisitor, context); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + function destructuringAndImportCallVisitor(node) { + if (ts.isDestructuringAssignment(node)) { + return visitDestructuringAssignment(node); + } + else if (ts.isImportCall(node)) { + return visitImportCallExpression(node); + } + else if ((node.transformFlags & 1024) || (node.transformFlags & 2097152)) { + return ts.visitEachChild(node, destructuringAndImportCallVisitor, context); + } + else { + return node; + } + } + function visitImportCallExpression(node) { + return ts.createCall(ts.createPropertyAccess(contextObject, ts.createIdentifier("import")), undefined, ts.some(node.arguments) ? [ts.visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : []); + } + function visitDestructuringAssignment(node) { + if (hasExportedReferenceInDestructuringTarget(node.left)) { + return ts.flattenDestructuringAssignment(node, destructuringAndImportCallVisitor, context, 0, true); + } + return ts.visitEachChild(node, destructuringAndImportCallVisitor, context); + } + function hasExportedReferenceInDestructuringTarget(node) { + if (ts.isAssignmentExpression(node, true)) { + return hasExportedReferenceInDestructuringTarget(node.left); + } + else if (ts.isSpreadElement(node)) { + return hasExportedReferenceInDestructuringTarget(node.expression); + } + else if (ts.isObjectLiteralExpression(node)) { + return ts.some(node.properties, hasExportedReferenceInDestructuringTarget); + } + else if (ts.isArrayLiteralExpression(node)) { + return ts.some(node.elements, hasExportedReferenceInDestructuringTarget); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return hasExportedReferenceInDestructuringTarget(node.name); + } + else if (ts.isPropertyAssignment(node)) { + return hasExportedReferenceInDestructuringTarget(node.initializer); + } + else if (ts.isIdentifier(node)) { + var container = resolver.getReferencedExportContainer(node); + return container !== undefined && container.kind === 290; + } + else { + return false; + } + } + function modifierVisitor(node) { + switch (node.kind) { + case 89: + case 84: + return undefined; + } + return node; + } + function onEmitNode(hint, node, emitCallback) { + if (node.kind === 290) { + var id = ts.getOriginalNodeId(node); + currentSourceFile = node; + moduleInfo = moduleInfoMap[id]; + exportFunction = exportFunctionsMap[id]; + noSubstitution = noSubstitutionMap[id]; + contextObject = contextObjectMap[id]; + if (noSubstitution) { + delete noSubstitutionMap[id]; + } + previousOnEmitNode(hint, node, emitCallback); + currentSourceFile = undefined; + moduleInfo = undefined; + exportFunction = undefined; + contextObject = undefined; + noSubstitution = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (isSubstitutionPrevented(node)) { + return node; + } + if (hint === 1) { + return substituteExpression(node); + } + else if (hint === 4) { + return substituteUnspecified(node); + } + return node; + } + function substituteUnspecified(node) { + switch (node.kind) { + case 282: + return substituteShorthandPropertyAssignment(node); + } + return node; + } + function substituteShorthandPropertyAssignment(node) { + var name = node.name; + if (!ts.isGeneratedIdentifier(name) && !ts.isLocalName(name)) { + var importDeclaration = resolver.getReferencedImportDeclaration(name); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(ts.createPropertyAssignment(ts.getSynthesizedClone(name), ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default"))), node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + return ts.setTextRange(ts.createPropertyAssignment(ts.getSynthesizedClone(name), ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name))), node); + } + } + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 75: + return substituteExpressionIdentifier(node); + case 209: + return substituteBinaryExpression(node); + case 207: + case 208: + return substituteUnaryExpression(node); + case 219: + return substituteMetaProperty(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + if (ts.getEmitFlags(node) & 4096) { + var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); + if (externalHelpersModuleName) { + return ts.createPropertyAccess(externalHelpersModuleName, node); + } + return node; + } + if (!ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) { + var importDeclaration = resolver.getReferencedImportDeclaration(node); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default")), node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name)), node); + } + } + } + return node; + } + function substituteBinaryExpression(node) { + if (ts.isAssignmentOperator(node.operatorToken.kind) + && ts.isIdentifier(node.left) + && !ts.isGeneratedIdentifier(node.left) + && !ts.isLocalName(node.left) + && !ts.isDeclarationNameOfEnumOrNamespace(node.left)) { + var exportedNames = getExports(node.left); + if (exportedNames) { + var expression = node; + for (var _i = 0, exportedNames_4 = exportedNames; _i < exportedNames_4.length; _i++) { + var exportName = exportedNames_4[_i]; + expression = createExportExpression(exportName, preventSubstitution(expression)); + } + return expression; + } + } + return node; + } + function substituteUnaryExpression(node) { + if ((node.operator === 45 || node.operator === 46) + && ts.isIdentifier(node.operand) + && !ts.isGeneratedIdentifier(node.operand) + && !ts.isLocalName(node.operand) + && !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) { + var exportedNames = getExports(node.operand); + if (exportedNames) { + var expression = node.kind === 208 + ? ts.setTextRange(ts.createPrefix(node.operator, node.operand), node) + : node; + for (var _i = 0, exportedNames_5 = exportedNames; _i < exportedNames_5.length; _i++) { + var exportName = exportedNames_5[_i]; + expression = createExportExpression(exportName, preventSubstitution(expression)); + } + if (node.kind === 208) { + expression = node.operator === 45 + ? ts.createSubtract(preventSubstitution(expression), ts.createLiteral(1)) + : ts.createAdd(preventSubstitution(expression), ts.createLiteral(1)); + } + return expression; + } + } + return node; + } + function substituteMetaProperty(node) { + if (ts.isImportMeta(node)) { + return ts.createPropertyAccess(contextObject, ts.createIdentifier("meta")); + } + return node; + } + function getExports(name) { + var exportedNames; + if (!ts.isGeneratedIdentifier(name)) { + var valueDeclaration = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (valueDeclaration) { + var exportContainer = resolver.getReferencedExportContainer(name, false); + if (exportContainer && exportContainer.kind === 290) { + exportedNames = ts.append(exportedNames, ts.getDeclarationName(valueDeclaration)); + } + exportedNames = ts.addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[ts.getOriginalNodeId(valueDeclaration)]); + } + } + return exportedNames; + } + function preventSubstitution(node) { + if (noSubstitution === undefined) + noSubstitution = []; + noSubstitution[ts.getNodeId(node)] = true; + return node; + } + function isSubstitutionPrevented(node) { + return noSubstitution && node.id && noSubstitution[node.id]; + } + } + ts.transformSystemModule = transformSystemModule; +})(ts || (ts = {})); +var ts; +(function (ts) { + function transformECMAScriptModule(context) { + var compilerOptions = context.getCompilerOptions(); + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.enableEmitNotification(290); + context.enableSubstitution(75); + var helperNameSubstitutions; + return ts.chainBundle(transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + if (ts.isExternalModule(node) || compilerOptions.isolatedModules) { + var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(node, compilerOptions); + if (externalHelpersImportDeclaration) { + var statements = []; + var statementOffset = ts.addPrologue(statements, node.statements); + ts.append(statements, externalHelpersImportDeclaration); + ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset)); + return ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(statements), node.statements)); + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + return node; + } + function visitor(node) { + switch (node.kind) { + case 253: + return undefined; + case 259: + return visitExportAssignment(node); + case 260: + var exportDecl = node; + return visitExportDeclaration(exportDecl); + } + return node; + } + function visitExportAssignment(node) { + return node.isExportEquals ? undefined : node; + } + function visitExportDeclaration(node) { + if (compilerOptions.module !== undefined && compilerOptions.module > ts.ModuleKind.ES2015) { + return node; + } + if (!node.exportClause || !ts.isNamespaceExport(node.exportClause) || !node.moduleSpecifier) { + return node; + } + var oldIdentifier = node.exportClause.name; + var synthName = ts.getGeneratedNameForNode(oldIdentifier); + var importDecl = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(synthName)), node.moduleSpecifier); + ts.setOriginalNode(importDecl, node.exportClause); + var exportDecl = ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(synthName, oldIdentifier)])); + ts.setOriginalNode(exportDecl, node); + return [importDecl, exportDecl]; + } + function onEmitNode(hint, node, emitCallback) { + if (ts.isSourceFile(node)) { + if ((ts.isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) { + helperNameSubstitutions = ts.createMap(); + } + previousOnEmitNode(hint, node, emitCallback); + helperNameSubstitutions = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (helperNameSubstitutions && ts.isIdentifier(node) && ts.getEmitFlags(node) & 4096) { + return substituteHelperName(node); + } + return node; + } + function substituteHelperName(node) { + var name = ts.idText(node); + var substitution = helperNameSubstitutions.get(name); + if (!substitution) { + helperNameSubstitutions.set(name, substitution = ts.createFileLevelUniqueName(name)); + } + return substitution; + } + } + ts.transformECMAScriptModule = transformECMAScriptModule; +})(ts || (ts = {})); +var ts; +(function (ts) { + function canProduceDiagnostics(node) { + return ts.isVariableDeclaration(node) || + ts.isPropertyDeclaration(node) || + ts.isPropertySignature(node) || + ts.isBindingElement(node) || + ts.isSetAccessor(node) || + ts.isGetAccessor(node) || + ts.isConstructSignatureDeclaration(node) || + ts.isCallSignatureDeclaration(node) || + ts.isMethodDeclaration(node) || + ts.isMethodSignature(node) || + ts.isFunctionDeclaration(node) || + ts.isParameter(node) || + ts.isTypeParameterDeclaration(node) || + ts.isExpressionWithTypeArguments(node) || + ts.isImportEqualsDeclaration(node) || + ts.isTypeAliasDeclaration(node) || + ts.isConstructorDeclaration(node) || + ts.isIndexSignatureDeclaration(node) || + ts.isPropertyAccessExpression(node); + } + ts.canProduceDiagnostics = canProduceDiagnostics; + function createGetSymbolAccessibilityDiagnosticForNodeName(node) { + if (ts.isSetAccessor(node) || ts.isGetAccessor(node)) { + return getAccessorNameVisibilityError; + } + else if (ts.isMethodSignature(node) || ts.isMethodDeclaration(node)) { + return getMethodNameVisibilityError; + } + else { + return createGetSymbolAccessibilityDiagnosticForNode(node); + } + function getAccessorNameVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (ts.hasModifier(node, 32)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 245) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + function getMethodNameVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (ts.hasModifier(node, 32)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 245) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Method_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + } + ts.createGetSymbolAccessibilityDiagnosticForNodeName = createGetSymbolAccessibilityDiagnosticForNodeName; + function createGetSymbolAccessibilityDiagnosticForNode(node) { + if (ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isPropertyAccessExpression(node) || ts.isBindingElement(node) || ts.isConstructorDeclaration(node)) { + return getVariableDeclarationTypeVisibilityError; + } + else if (ts.isSetAccessor(node) || ts.isGetAccessor(node)) { + return getAccessorDeclarationTypeVisibilityError; + } + else if (ts.isConstructSignatureDeclaration(node) || ts.isCallSignatureDeclaration(node) || ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isFunctionDeclaration(node) || ts.isIndexSignatureDeclaration(node)) { + return getReturnTypeVisibilityError; + } + else if (ts.isParameter(node)) { + if (ts.isParameterPropertyDeclaration(node, node.parent) && ts.hasModifier(node.parent, 8)) { + return getVariableDeclarationTypeVisibilityError; + } + return getParameterDeclarationTypeVisibilityError; + } + else if (ts.isTypeParameterDeclaration(node)) { + return getTypeParameterConstraintVisibilityError; + } + else if (ts.isExpressionWithTypeArguments(node)) { + return getHeritageClauseVisibilityError; + } + else if (ts.isImportEqualsDeclaration(node)) { + return getImportEntityNameVisibilityError; + } + else if (ts.isTypeAliasDeclaration(node)) { + return getTypeAliasDeclarationVisibilityError; + } + else { + return ts.Debug.assertNever(node, "Attempted to set a declaration diagnostic context for unhandled node kind: " + ts.SyntaxKind[node.kind]); + } + function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (node.kind === 242 || node.kind === 191) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; + } + else if (node.kind === 159 || node.kind === 194 || node.kind === 158 || + (node.kind === 156 && ts.hasModifier(node.parent, 8))) { + if (ts.hasModifier(node, 32)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 245 || node.kind === 156) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + } + function getVariableDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage; + if (node.kind === 164) { + if (ts.hasModifier(node, 32)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1; + } + } + else { + if (ts.hasModifier(node, 32)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1; + } + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node.name, + typeName: node.name + }; + } + function getReturnTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage; + switch (node.kind) { + case 166: + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 165: + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 167: + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 161: + case 160: + if (ts.hasModifier(node, 32)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; + } + else if (node.parent.kind === 245) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; + } + else { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; + } + break; + case 244: + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; + break; + default: + return ts.Debug.fail("This is unknown kind for signature: " + node.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node.name || node + }; + } + function getParameterDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) { + switch (node.parent.kind) { + case 162: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; + case 166: + case 171: + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + case 165: + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + case 167: + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1; + case 161: + case 160: + if (ts.hasModifier(node.parent, 32)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.parent.kind === 245) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + } + case 244: + case 170: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; + case 164: + case 163: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 ? + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_private_name_1; + default: + return ts.Debug.fail("Unknown parent for parameter: " + ts.SyntaxKind[node.parent.kind]); + } + } + function getTypeParameterConstraintVisibilityError() { + var diagnosticMessage; + switch (node.parent.kind) { + case 245: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; + break; + case 246: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; + break; + case 186: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1; + break; + case 171: + case 166: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 165: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 161: + case 160: + if (ts.hasModifier(node.parent, 32)) { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.parent.kind === 245) { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + } + break; + case 170: + case 244: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + case 247: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1; + break; + default: + return ts.Debug.fail("This is unknown parent for type parameter: " + node.parent.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + }; + } + function getHeritageClauseVisibilityError() { + var diagnosticMessage; + if (node.parent.parent.kind === 245) { + diagnosticMessage = ts.isHeritageClause(node.parent) && node.parent.token === 113 ? + ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : + ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = ts.Diagnostics.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1; + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: ts.getNameOfDeclaration(node.parent.parent) + }; + } + function getImportEntityNameVisibilityError() { + return { + diagnosticMessage: ts.Diagnostics.Import_declaration_0_is_using_private_name_1, + errorNode: node, + typeName: node.name + }; + } + function getTypeAliasDeclarationVisibilityError() { + return { + diagnosticMessage: ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, + errorNode: node.type, + typeName: node.name + }; + } + } + ts.createGetSymbolAccessibilityDiagnosticForNode = createGetSymbolAccessibilityDiagnosticForNode; +})(ts || (ts = {})); +var ts; +(function (ts) { + function getDeclarationDiagnostics(host, resolver, file) { + if (file && ts.isJsonSourceFile(file)) { + return []; + } + var compilerOptions = host.getCompilerOptions(); + var result = ts.transformNodes(resolver, host, compilerOptions, file ? [file] : ts.filter(host.getSourceFiles(), ts.isSourceFileNotJson), [transformDeclarations], false); + return result.diagnostics; + } + ts.getDeclarationDiagnostics = getDeclarationDiagnostics; + function hasInternalAnnotation(range, currentSourceFile) { + var comment = currentSourceFile.text.substring(range.pos, range.end); + return ts.stringContains(comment, "@internal"); + } + function isInternalDeclaration(node, currentSourceFile) { + var parseTreeNode = ts.getParseTreeNode(node); + if (parseTreeNode && parseTreeNode.kind === 156) { + var paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode); + var previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : undefined; + var text = currentSourceFile.text; + var commentRanges = previousSibling + ? ts.concatenate(ts.getTrailingCommentRanges(text, ts.skipTrivia(text, previousSibling.end + 1, false, true)), ts.getLeadingCommentRanges(text, node.pos)) + : ts.getTrailingCommentRanges(text, ts.skipTrivia(text, node.pos, false, true)); + return commentRanges && commentRanges.length && hasInternalAnnotation(ts.last(commentRanges), currentSourceFile); + } + var leadingCommentRanges = parseTreeNode && ts.getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile); + return !!ts.forEach(leadingCommentRanges, function (range) { + return hasInternalAnnotation(range, currentSourceFile); + }); + } + ts.isInternalDeclaration = isInternalDeclaration; + var declarationEmitNodeBuilderFlags = 1024 | + 2048 | + 4096 | + 8 | + 524288 | + 4 | + 1; + function transformDeclarations(context) { + var throwDiagnostic = function () { return ts.Debug.fail("Diagnostic emitted without context"); }; + var getSymbolAccessibilityDiagnostic = throwDiagnostic; + var needsDeclare = true; + var isBundledEmit = false; + var resultHasExternalModuleIndicator = false; + var needsScopeFixMarker = false; + var resultHasScopeMarker = false; + var enclosingDeclaration; + var necessaryTypeReferences; + var lateMarkedStatements; + var lateStatementReplacementMap; + var suppressNewDiagnosticContexts; + var exportedModulesFromDeclarationEmit; + var host = context.getEmitHost(); + var symbolTracker = { + trackSymbol: trackSymbol, + reportInaccessibleThisError: reportInaccessibleThisError, + reportInaccessibleUniqueSymbolError: reportInaccessibleUniqueSymbolError, + reportPrivateInBaseOfClassExpression: reportPrivateInBaseOfClassExpression, + reportLikelyUnsafeImportRequiredError: reportLikelyUnsafeImportRequiredError, + moduleResolverHost: host, + trackReferencedAmbientModule: trackReferencedAmbientModule, + trackExternalModuleSymbolOfImportTypeNode: trackExternalModuleSymbolOfImportTypeNode + }; + var errorNameNode; + var currentSourceFile; + var refs; + var libs; + var emittedImports; + var resolver = context.getEmitResolver(); + var options = context.getCompilerOptions(); + var noResolve = options.noResolve, stripInternal = options.stripInternal; + return transformRoot; + function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) { + if (!typeReferenceDirectives) { + return; + } + necessaryTypeReferences = necessaryTypeReferences || ts.createMap(); + for (var _i = 0, typeReferenceDirectives_2 = typeReferenceDirectives; _i < typeReferenceDirectives_2.length; _i++) { + var ref = typeReferenceDirectives_2[_i]; + necessaryTypeReferences.set(ref, true); + } + } + function trackReferencedAmbientModule(node, symbol) { + var directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, 67108863); + if (ts.length(directives)) { + return recordTypeReferenceDirectivesIfNecessary(directives); + } + var container = ts.getSourceFileOfNode(node); + refs.set("" + ts.getOriginalNodeId(container), container); + } + function handleSymbolAccessibilityError(symbolAccessibilityResult) { + if (symbolAccessibilityResult.accessibility === 0) { + if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) { + if (!lateMarkedStatements) { + lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible; + } + else { + for (var _i = 0, _a = symbolAccessibilityResult.aliasesToMakeVisible; _i < _a.length; _i++) { + var ref = _a[_i]; + ts.pushIfUnique(lateMarkedStatements, ref); + } + } + } + } + else { + var errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult); + if (errorInfo) { + if (errorInfo.typeName) { + context.addDiagnostic(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, ts.getTextOfNode(errorInfo.typeName), symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName)); + } + else { + context.addDiagnostic(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName)); + } + } + } + } + function trackExternalModuleSymbolOfImportTypeNode(symbol) { + if (!isBundledEmit) { + (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol); + } + } + function trackSymbol(symbol, enclosingDeclaration, meaning) { + if (symbol.flags & 262144) + return; + handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, true)); + recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning)); + } + function reportPrivateInBaseOfClassExpression(propertyName) { + if (errorNameNode) { + context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)); + } + } + function reportInaccessibleUniqueSymbolError() { + if (errorNameNode) { + context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), "unique symbol")); + } + } + function reportInaccessibleThisError() { + if (errorNameNode) { + context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), "this")); + } + } + function reportLikelyUnsafeImportRequiredError(specifier) { + if (errorNameNode) { + context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), specifier)); + } + } + function transformDeclarationsForJS(sourceFile, bundled) { + var oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = function (s) { return ({ + diagnosticMessage: s.errorModuleName + ? ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit + : ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit, + errorNode: s.errorNode || sourceFile + }); }; + var result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled); + getSymbolAccessibilityDiagnostic = oldDiag; + return result; + } + function transformRoot(node) { + if (node.kind === 290 && node.isDeclarationFile) { + return node; + } + if (node.kind === 291) { + isBundledEmit = true; + refs = ts.createMap(); + libs = ts.createMap(); + var hasNoDefaultLib_1 = false; + var bundle = ts.createBundle(ts.map(node.sourceFiles, function (sourceFile) { + if (sourceFile.isDeclarationFile) + return undefined; + hasNoDefaultLib_1 = hasNoDefaultLib_1 || sourceFile.hasNoDefaultLib; + currentSourceFile = sourceFile; + enclosingDeclaration = sourceFile; + lateMarkedStatements = undefined; + suppressNewDiagnosticContexts = false; + lateStatementReplacementMap = ts.createMap(); + getSymbolAccessibilityDiagnostic = throwDiagnostic; + needsScopeFixMarker = false; + resultHasScopeMarker = false; + collectReferences(sourceFile, refs); + collectLibs(sourceFile, libs); + if (ts.isExternalOrCommonJsModule(sourceFile) || ts.isJsonSourceFile(sourceFile)) { + resultHasExternalModuleIndicator = false; + needsDeclare = false; + var statements = ts.isSourceFileJS(sourceFile) ? ts.createNodeArray(transformDeclarationsForJS(sourceFile, true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements); + var newFile = ts.updateSourceFileNode(sourceFile, [ts.createModuleDeclaration([], [ts.createModifier(130)], ts.createLiteral(ts.getResolvedExternalModuleName(context.getEmitHost(), sourceFile)), ts.createModuleBlock(ts.setTextRange(ts.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)))], true, [], [], false, []); + return newFile; + } + needsDeclare = true; + var updated = ts.isSourceFileJS(sourceFile) ? ts.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements); + return ts.updateSourceFileNode(sourceFile, transformAndReplaceLatePaintedStatements(updated), true, [], [], false, []); + }), ts.mapDefined(node.prepends, function (prepend) { + if (prepend.kind === 293) { + var sourceFile = ts.createUnparsedSourceFile(prepend, "dts", stripInternal); + hasNoDefaultLib_1 = hasNoDefaultLib_1 || !!sourceFile.hasNoDefaultLib; + collectReferences(sourceFile, refs); + recordTypeReferenceDirectivesIfNecessary(sourceFile.typeReferenceDirectives); + collectLibs(sourceFile, libs); + return sourceFile; + } + return prepend; + })); + bundle.syntheticFileReferences = []; + bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences(); + bundle.syntheticLibReferences = getLibReferences(); + bundle.hasNoDefaultLib = hasNoDefaultLib_1; + var outputFilePath_1 = ts.getDirectoryPath(ts.normalizeSlashes(ts.getOutputPathsFor(node, host, true).declarationFilePath)); + var referenceVisitor_1 = mapReferencesIntoArray(bundle.syntheticFileReferences, outputFilePath_1); + refs.forEach(referenceVisitor_1); + return bundle; + } + needsDeclare = true; + needsScopeFixMarker = false; + resultHasScopeMarker = false; + enclosingDeclaration = node; + currentSourceFile = node; + getSymbolAccessibilityDiagnostic = throwDiagnostic; + isBundledEmit = false; + resultHasExternalModuleIndicator = false; + suppressNewDiagnosticContexts = false; + lateMarkedStatements = undefined; + lateStatementReplacementMap = ts.createMap(); + necessaryTypeReferences = undefined; + refs = collectReferences(currentSourceFile, ts.createMap()); + libs = collectLibs(currentSourceFile, ts.createMap()); + var references = []; + var outputFilePath = ts.getDirectoryPath(ts.normalizeSlashes(ts.getOutputPathsFor(node, host, true).declarationFilePath)); + var referenceVisitor = mapReferencesIntoArray(references, outputFilePath); + var combinedStatements; + if (ts.isSourceFileJS(currentSourceFile)) { + combinedStatements = ts.createNodeArray(transformDeclarationsForJS(node)); + refs.forEach(referenceVisitor); + emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax); + } + else { + var statements = ts.visitNodes(node.statements, visitDeclarationStatements); + combinedStatements = ts.setTextRange(ts.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements); + refs.forEach(referenceVisitor); + emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax); + if (ts.isExternalModule(node) && (!resultHasExternalModuleIndicator || (needsScopeFixMarker && !resultHasScopeMarker))) { + combinedStatements = ts.setTextRange(ts.createNodeArray(__spreadArrays(combinedStatements, [ts.createEmptyExports()])), combinedStatements); + } + } + var updated = ts.updateSourceFileNode(node, combinedStatements, true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences()); + updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit; + return updated; + function getLibReferences() { + return ts.map(ts.arrayFrom(libs.keys()), function (lib) { return ({ fileName: lib, pos: -1, end: -1 }); }); + } + function getFileReferencesForUsedTypeReferences() { + return necessaryTypeReferences ? ts.mapDefined(ts.arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForTypeName) : []; + } + function getFileReferenceForTypeName(typeName) { + if (emittedImports) { + for (var _i = 0, emittedImports_1 = emittedImports; _i < emittedImports_1.length; _i++) { + var importStatement = emittedImports_1[_i]; + if (ts.isImportEqualsDeclaration(importStatement) && ts.isExternalModuleReference(importStatement.moduleReference)) { + var expr = importStatement.moduleReference.expression; + if (ts.isStringLiteralLike(expr) && expr.text === typeName) { + return undefined; + } + } + else if (ts.isImportDeclaration(importStatement) && ts.isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) { + return undefined; + } + } + } + return { fileName: typeName, pos: -1, end: -1 }; + } + function mapReferencesIntoArray(references, outputFilePath) { + return function (file) { + var declFileName; + if (file.isDeclarationFile) { + declFileName = file.fileName; + } + else { + if (isBundledEmit && ts.contains(node.sourceFiles, file)) + return; + var paths = ts.getOutputPathsFor(file, host, true); + declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName; + } + if (declFileName) { + var specifier = ts.moduleSpecifiers.getModuleSpecifier(__assign(__assign({}, options), { baseUrl: options.baseUrl && ts.toPath(options.baseUrl, host.getCurrentDirectory(), host.getCanonicalFileName) }), currentSourceFile, ts.toPath(outputFilePath, host.getCurrentDirectory(), host.getCanonicalFileName), ts.toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName), host, host.getSourceFiles(), undefined, host.redirectTargetsMap); + if (!ts.pathIsRelative(specifier)) { + recordTypeReferenceDirectivesIfNecessary([specifier]); + return; + } + var fileName = ts.getRelativePathToDirectoryOrUrl(outputFilePath, declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, false); + if (ts.startsWith(fileName, "./") && ts.hasExtension(fileName)) { + fileName = fileName.substring(2); + } + if (ts.startsWith(fileName, "node_modules/") || fileName.indexOf("/node_modules/") !== -1) { + return; + } + references.push({ pos: -1, end: -1, fileName: fileName }); + } + }; + } + } + function collectReferences(sourceFile, ret) { + if (noResolve || (!ts.isUnparsedSource(sourceFile) && ts.isSourceFileJS(sourceFile))) + return ret; + ts.forEach(sourceFile.referencedFiles, function (f) { + var elem = host.getSourceFileFromReference(sourceFile, f); + if (elem) { + ret.set("" + ts.getOriginalNodeId(elem), elem); + } + }); + return ret; + } + function collectLibs(sourceFile, ret) { + ts.forEach(sourceFile.libReferenceDirectives, function (ref) { + var lib = host.getLibFileFromReference(ref); + if (lib) { + ret.set(ts.toFileNameLowerCase(ref.fileName), true); + } + }); + return ret; + } + function filterBindingPatternInitializers(name) { + if (name.kind === 75) { + return name; + } + else { + if (name.kind === 190) { + return ts.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement)); + } + else { + return ts.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement)); + } + } + function visitBindingElement(elem) { + if (elem.kind === 215) { + return elem; + } + return ts.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined); + } + } + function ensureParameter(p, modifierMask, type) { + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p); + } + var newParam = ts.updateParameter(p, undefined, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || ts.createToken(57)) : undefined, ensureType(p, type || p.type, true), ensureNoInitializer(p)); + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + return newParam; + } + function shouldPrintWithInitializer(node) { + return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(ts.getParseTreeNode(node)); + } + function ensureNoInitializer(node) { + if (shouldPrintWithInitializer(node)) { + return resolver.createLiteralConstValue(ts.getParseTreeNode(node), symbolTracker); + } + return undefined; + } + function ensureType(node, type, ignorePrivate) { + if (!ignorePrivate && ts.hasModifier(node, 8)) { + return; + } + if (shouldPrintWithInitializer(node)) { + return; + } + var shouldUseResolverType = node.kind === 156 && + (resolver.isRequiredInitializedParameter(node) || + resolver.isOptionalUninitializedParameterProperty(node)); + if (type && !shouldUseResolverType) { + return ts.visitNode(type, visitDeclarationSubtree); + } + if (!ts.getParseTreeNode(node)) { + return type ? ts.visitNode(type, visitDeclarationSubtree) : ts.createKeywordTypeNode(125); + } + if (node.kind === 164) { + return ts.createKeywordTypeNode(125); + } + errorNameNode = node.name; + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(node); + } + if (node.kind === 242 || node.kind === 191) { + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + } + if (node.kind === 156 + || node.kind === 159 + || node.kind === 158) { + if (!node.initializer) + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType)); + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + } + return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + function cleanup(returnValue) { + errorNameNode = undefined; + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + return returnValue || ts.createKeywordTypeNode(125); + } + } + function isDeclarationAndNotVisible(node) { + node = ts.getParseTreeNode(node); + switch (node.kind) { + case 244: + case 249: + case 246: + case 245: + case 247: + case 248: + return !resolver.isDeclarationVisible(node); + case 242: + return !getBindingNameVisible(node); + case 253: + case 254: + case 260: + case 259: + return false; + } + return false; + } + function getBindingNameVisible(elem) { + if (ts.isOmittedExpression(elem)) { + return false; + } + if (ts.isBindingPattern(elem.name)) { + return ts.some(elem.name.elements, getBindingNameVisible); + } + else { + return resolver.isDeclarationVisible(elem); + } + } + function updateParamsList(node, params, modifierMask) { + if (ts.hasModifier(node, 8)) { + return undefined; + } + var newParams = ts.map(params, function (p) { return ensureParameter(p, modifierMask); }); + if (!newParams) { + return undefined; + } + return ts.createNodeArray(newParams, params.hasTrailingComma); + } + function updateAccessorParamsList(input, isPrivate) { + var newParams; + if (!isPrivate) { + var thisParameter = ts.getThisParameter(input); + if (thisParameter) { + newParams = [ensureParameter(thisParameter)]; + } + } + if (ts.isSetAccessorDeclaration(input)) { + var newValueParameter = void 0; + if (!isPrivate) { + var valueParameter = ts.getSetAccessorValueParameter(input); + if (valueParameter) { + var accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); + newValueParameter = ensureParameter(valueParameter, undefined, accessorType); + } + } + if (!newValueParameter) { + newValueParameter = ts.createParameter(undefined, undefined, undefined, "value"); + } + newParams = ts.append(newParams, newValueParameter); + } + return ts.createNodeArray(newParams || ts.emptyArray); + } + function ensureTypeParams(node, params) { + return ts.hasModifier(node, 8) ? undefined : ts.visitNodes(params, visitDeclarationSubtree); + } + function isEnclosingDeclaration(node) { + return ts.isSourceFile(node) + || ts.isTypeAliasDeclaration(node) + || ts.isModuleDeclaration(node) + || ts.isClassDeclaration(node) + || ts.isInterfaceDeclaration(node) + || ts.isFunctionLike(node) + || ts.isIndexSignatureDeclaration(node) + || ts.isMappedTypeNode(node); + } + function checkEntityNameVisibility(entityName, enclosingDeclaration) { + var visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration); + handleSymbolAccessibilityError(visibilityResult); + recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName)); + } + function preserveJsDoc(updated, original) { + if (ts.hasJSDocNodes(updated) && ts.hasJSDocNodes(original)) { + updated.jsDoc = original.jsDoc; + } + return ts.setCommentRange(updated, ts.getCommentRange(original)); + } + function rewriteModuleSpecifier(parent, input) { + if (!input) + return undefined; + resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || (parent.kind !== 249 && parent.kind !== 188); + if (ts.isStringLiteralLike(input)) { + if (isBundledEmit) { + var newName = ts.getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent); + if (newName) { + return ts.createLiteral(newName); + } + } + else { + var symbol = resolver.getSymbolOfExternalModuleSpecifier(input); + if (symbol) { + (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol); + } + } + } + return input; + } + function transformImportEqualsDeclaration(decl) { + if (!resolver.isDeclarationVisible(decl)) + return; + if (decl.moduleReference.kind === 265) { + var specifier = ts.getExternalModuleImportEqualsDeclarationExpression(decl); + return ts.updateImportEqualsDeclaration(decl, undefined, decl.modifiers, decl.name, ts.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))); + } + else { + var oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(decl); + checkEntityNameVisibility(decl.moduleReference, enclosingDeclaration); + getSymbolAccessibilityDiagnostic = oldDiag; + return decl; + } + } + function transformImportDeclaration(decl) { + if (!decl.importClause) { + return ts.updateImportDeclaration(decl, undefined, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier)); + } + var visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : undefined; + if (!decl.importClause.namedBindings) { + return visibleDefaultBinding && ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, undefined, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier)); + } + if (decl.importClause.namedBindings.kind === 256) { + var namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : undefined; + return visibleDefaultBinding || namedBindings ? ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, namedBindings, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier)) : undefined; + } + var bindingList = ts.mapDefined(decl.importClause.namedBindings.elements, function (b) { return resolver.isDeclarationVisible(b) ? b : undefined; }); + if ((bindingList && bindingList.length) || visibleDefaultBinding) { + return ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, bindingList && bindingList.length ? ts.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier)); + } + } + function transformAndReplaceLatePaintedStatements(statements) { + while (ts.length(lateMarkedStatements)) { + var i = lateMarkedStatements.shift(); + if (!ts.isLateVisibilityPaintedStatement(i)) { + return ts.Debug.fail("Late replaced statement was found which is not handled by the declaration transformer!: " + (ts.SyntaxKind ? ts.SyntaxKind[i.kind] : i.kind)); + } + var priorNeedsDeclare = needsDeclare; + needsDeclare = i.parent && ts.isSourceFile(i.parent) && !(ts.isExternalModule(i.parent) && isBundledEmit); + var result = transformTopLevelDeclaration(i); + needsDeclare = priorNeedsDeclare; + lateStatementReplacementMap.set("" + ts.getOriginalNodeId(i), result); + } + return ts.visitNodes(statements, visitLateVisibilityMarkedStatements); + function visitLateVisibilityMarkedStatements(statement) { + if (ts.isLateVisibilityPaintedStatement(statement)) { + var key = "" + ts.getOriginalNodeId(statement); + if (lateStatementReplacementMap.has(key)) { + var result = lateStatementReplacementMap.get(key); + lateStatementReplacementMap.delete(key); + if (result) { + if (ts.isArray(result) ? ts.some(result, ts.needsScopeMarker) : ts.needsScopeMarker(result)) { + needsScopeFixMarker = true; + } + if (ts.isSourceFile(statement.parent) && (ts.isArray(result) ? ts.some(result, ts.isExternalModuleIndicator) : ts.isExternalModuleIndicator(result))) { + resultHasExternalModuleIndicator = true; + } + } + return result; + } + } + return statement; + } + } + function visitDeclarationSubtree(input) { + if (shouldStripInternal(input)) + return; + if (ts.isDeclaration(input)) { + if (isDeclarationAndNotVisible(input)) + return; + if (ts.hasDynamicName(input) && !resolver.isLateBound(ts.getParseTreeNode(input))) { + return; + } + } + if (ts.isFunctionLike(input) && resolver.isImplementationOfOverload(input)) + return; + if (ts.isSemicolonClassElement(input)) + return; + var previousEnclosingDeclaration; + if (isEnclosingDeclaration(input)) { + previousEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = input; + } + var oldDiag = getSymbolAccessibilityDiagnostic; + var canProduceDiagnostic = ts.canProduceDiagnostics(input); + var oldWithinObjectLiteralType = suppressNewDiagnosticContexts; + var shouldEnterSuppressNewDiagnosticsContextContext = ((input.kind === 173 || input.kind === 186) && input.parent.kind !== 247); + if (ts.isMethodDeclaration(input) || ts.isMethodSignature(input)) { + if (ts.hasModifier(input, 8)) { + if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input) + return; + return cleanup(ts.createProperty(undefined, ensureModifiers(input), input.name, undefined, undefined, undefined)); + } + } + if (canProduceDiagnostic && !suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(input); + } + if (ts.isTypeQueryNode(input)) { + checkEntityNameVisibility(input.exprName, enclosingDeclaration); + } + if (shouldEnterSuppressNewDiagnosticsContextContext) { + suppressNewDiagnosticContexts = true; + } + if (isProcessedComponent(input)) { + switch (input.kind) { + case 216: { + if ((ts.isEntityName(input.expression) || ts.isEntityNameExpression(input.expression))) { + checkEntityNameVisibility(input.expression, enclosingDeclaration); + } + var node = ts.visitEachChild(input, visitDeclarationSubtree, context); + return cleanup(ts.updateExpressionWithTypeArguments(node, ts.parenthesizeTypeParameters(node.typeArguments), node.expression)); + } + case 169: { + checkEntityNameVisibility(input.typeName, enclosingDeclaration); + var node = ts.visitEachChild(input, visitDeclarationSubtree, context); + return cleanup(ts.updateTypeReferenceNode(node, node.typeName, ts.parenthesizeTypeParameters(node.typeArguments))); + } + case 166: + return cleanup(ts.updateConstructSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type))); + case 162: { + var ctor = ts.createSignatureDeclaration(162, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters, 0), undefined); + ctor.modifiers = ts.createNodeArray(ensureModifiers(input)); + return cleanup(ctor); + } + case 161: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + var sig = ts.createSignatureDeclaration(160, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)); + sig.name = input.name; + sig.modifiers = ts.createNodeArray(ensureModifiers(input)); + sig.questionToken = input.questionToken; + return cleanup(sig); + } + case 163: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + var accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); + return cleanup(ts.updateGetAccessor(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasModifier(input, 8)), ensureType(input, accessorType), undefined)); + } + case 164: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + return cleanup(ts.updateSetAccessor(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasModifier(input, 8)), undefined)); + } + case 159: + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + return cleanup(ts.updateProperty(input, undefined, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input))); + case 158: + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + return cleanup(ts.updatePropertySignature(input, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input))); + case 160: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(undefined); + } + return cleanup(ts.updateMethodSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), input.name, input.questionToken)); + } + case 165: { + return cleanup(ts.updateCallSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type))); + } + case 167: { + return cleanup(ts.updateIndexSignature(input, undefined, ensureModifiers(input), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree) || ts.createKeywordTypeNode(125))); + } + case 242: { + if (ts.isBindingPattern(input.name)) { + return recreateBindingPattern(input.name); + } + shouldEnterSuppressNewDiagnosticsContextContext = true; + suppressNewDiagnosticContexts = true; + return cleanup(ts.updateTypeScriptVariableDeclaration(input, input.name, undefined, ensureType(input, input.type), ensureNoInitializer(input))); + } + case 155: { + if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) { + return cleanup(ts.updateTypeParameterDeclaration(input, input.name, undefined, undefined)); + } + return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context)); + } + case 180: { + var checkType = ts.visitNode(input.checkType, visitDeclarationSubtree); + var extendsType = ts.visitNode(input.extendsType, visitDeclarationSubtree); + var oldEnclosingDecl = enclosingDeclaration; + enclosingDeclaration = input.trueType; + var trueType = ts.visitNode(input.trueType, visitDeclarationSubtree); + enclosingDeclaration = oldEnclosingDecl; + var falseType = ts.visitNode(input.falseType, visitDeclarationSubtree); + return cleanup(ts.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType)); + } + case 170: { + return cleanup(ts.updateFunctionTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); + } + case 171: { + return cleanup(ts.updateConstructorTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); + } + case 188: { + if (!ts.isLiteralImportTypeNode(input)) + return cleanup(input); + return cleanup(ts.updateImportTypeNode(input, ts.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), input.qualifier, ts.visitNodes(input.typeArguments, visitDeclarationSubtree, ts.isTypeNode), input.isTypeOf)); + } + default: ts.Debug.assertNever(input, "Attempted to process unhandled node kind: " + ts.SyntaxKind[input.kind]); + } + } + return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context)); + function cleanup(returnValue) { + if (returnValue && canProduceDiagnostic && ts.hasDynamicName(input)) { + checkName(input); + } + if (isEnclosingDeclaration(input)) { + enclosingDeclaration = previousEnclosingDeclaration; + } + if (canProduceDiagnostic && !suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + if (shouldEnterSuppressNewDiagnosticsContextContext) { + suppressNewDiagnosticContexts = oldWithinObjectLiteralType; + } + if (returnValue === input) { + return returnValue; + } + return returnValue && ts.setOriginalNode(preserveJsDoc(returnValue, input), input); + } + } + function isPrivateMethodTypeParameter(node) { + return node.parent.kind === 161 && ts.hasModifier(node.parent, 8); + } + function visitDeclarationStatements(input) { + if (!isPreservedDeclarationStatement(input)) { + return; + } + if (shouldStripInternal(input)) + return; + switch (input.kind) { + case 260: { + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + return ts.updateExportDeclaration(input, undefined, input.modifiers, input.exportClause, rewriteModuleSpecifier(input, input.moduleSpecifier), input.isTypeOnly); + } + case 259: { + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + if (input.expression.kind === 75) { + return input; + } + else { + var newId = ts.createOptimisticUniqueName("_default"); + getSymbolAccessibilityDiagnostic = function () { return ({ + diagnosticMessage: ts.Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0, + errorNode: input + }); }; + var varDecl = ts.createVariableDeclaration(newId, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined); + var statement = ts.createVariableStatement(needsDeclare ? [ts.createModifier(130)] : [], ts.createVariableDeclarationList([varDecl], 2)); + return [statement, ts.updateExportAssignment(input, input.decorators, input.modifiers, newId)]; + } + } + } + var result = transformTopLevelDeclaration(input); + lateStatementReplacementMap.set("" + ts.getOriginalNodeId(input), result); + return input; + } + function stripExportModifiers(statement) { + if (ts.isImportEqualsDeclaration(statement) || ts.hasModifier(statement, 512)) { + return statement; + } + var clone = ts.getMutableClone(statement); + var modifiers = ts.createModifiersFromModifierFlags(ts.getModifierFlags(statement) & (3071 ^ 1)); + clone.modifiers = modifiers.length ? ts.createNodeArray(modifiers) : undefined; + return clone; + } + function transformTopLevelDeclaration(input) { + if (shouldStripInternal(input)) + return; + switch (input.kind) { + case 253: { + return transformImportEqualsDeclaration(input); + } + case 254: { + return transformImportDeclaration(input); + } + } + if (ts.isDeclaration(input) && isDeclarationAndNotVisible(input)) + return; + if (ts.isFunctionLike(input) && resolver.isImplementationOfOverload(input)) + return; + var previousEnclosingDeclaration; + if (isEnclosingDeclaration(input)) { + previousEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = input; + } + var canProdiceDiagnostic = ts.canProduceDiagnostics(input); + var oldDiag = getSymbolAccessibilityDiagnostic; + if (canProdiceDiagnostic) { + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(input); + } + var previousNeedsDeclare = needsDeclare; + switch (input.kind) { + case 247: + return cleanup(ts.updateTypeAliasDeclaration(input, undefined, ensureModifiers(input), input.name, ts.visitNodes(input.typeParameters, visitDeclarationSubtree, ts.isTypeParameterDeclaration), ts.visitNode(input.type, visitDeclarationSubtree, ts.isTypeNode))); + case 246: { + return cleanup(ts.updateInterfaceDeclaration(input, undefined, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree))); + } + case 244: { + var clean = cleanup(ts.updateFunctionDeclaration(input, undefined, ensureModifiers(input), undefined, input.name, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), undefined)); + if (clean && resolver.isExpandoFunctionDeclaration(input)) { + var props = resolver.getPropertiesOfContainerFunction(input); + var fakespace_1 = ts.createModuleDeclaration(undefined, undefined, clean.name || ts.createIdentifier("_default"), ts.createModuleBlock([]), 16); + fakespace_1.flags ^= 8; + fakespace_1.parent = enclosingDeclaration; + fakespace_1.locals = ts.createSymbolTable(props); + fakespace_1.symbol = props[0].parent; + var declarations = ts.mapDefined(props, function (p) { + if (!ts.isPropertyAccessExpression(p.valueDeclaration)) { + return undefined; + } + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration); + var type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace_1, declarationEmitNodeBuilderFlags, symbolTracker); + getSymbolAccessibilityDiagnostic = oldDiag; + var varDecl = ts.createVariableDeclaration(ts.unescapeLeadingUnderscores(p.escapedName), type, undefined); + return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([varDecl])); + }); + var namespaceDecl = ts.createModuleDeclaration(undefined, ensureModifiers(input), input.name, ts.createModuleBlock(declarations), 16); + if (!ts.hasModifier(clean, 512)) { + return [clean, namespaceDecl]; + } + var modifiers = ts.createModifiersFromModifierFlags((ts.getModifierFlags(clean) & ~513) | 2); + var cleanDeclaration = ts.updateFunctionDeclaration(clean, undefined, modifiers, undefined, clean.name, clean.typeParameters, clean.parameters, clean.type, undefined); + var namespaceDeclaration = ts.updateModuleDeclaration(namespaceDecl, undefined, modifiers, namespaceDecl.name, namespaceDecl.body); + var exportDefaultDeclaration = ts.createExportAssignment(undefined, undefined, false, namespaceDecl.name); + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + return [cleanDeclaration, namespaceDeclaration, exportDefaultDeclaration]; + } + else { + return clean; + } + } + case 249: { + needsDeclare = false; + var inner = input.body; + if (inner && inner.kind === 250) { + var oldNeedsScopeFix = needsScopeFixMarker; + var oldHasScopeFix = resultHasScopeMarker; + resultHasScopeMarker = false; + needsScopeFixMarker = false; + var statements = ts.visitNodes(inner.statements, visitDeclarationStatements); + var lateStatements = transformAndReplaceLatePaintedStatements(statements); + if (input.flags & 8388608) { + needsScopeFixMarker = false; + } + if (!ts.isGlobalScopeAugmentation(input) && !hasScopeMarker(lateStatements) && !resultHasScopeMarker) { + if (needsScopeFixMarker) { + lateStatements = ts.createNodeArray(__spreadArrays(lateStatements, [ts.createEmptyExports()])); + } + else { + lateStatements = ts.visitNodes(lateStatements, stripExportModifiers); + } + } + var body = ts.updateModuleBlock(inner, lateStatements); + needsDeclare = previousNeedsDeclare; + needsScopeFixMarker = oldNeedsScopeFix; + resultHasScopeMarker = oldHasScopeFix; + var mods = ensureModifiers(input); + return cleanup(ts.updateModuleDeclaration(input, undefined, mods, ts.isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name, body)); + } + else { + needsDeclare = previousNeedsDeclare; + var mods = ensureModifiers(input); + needsDeclare = false; + ts.visitNode(inner, visitDeclarationStatements); + var id = "" + ts.getOriginalNodeId(inner); + var body = lateStatementReplacementMap.get(id); + lateStatementReplacementMap.delete(id); + return cleanup(ts.updateModuleDeclaration(input, undefined, mods, input.name, body)); + } + } + case 245: { + var modifiers = ts.createNodeArray(ensureModifiers(input)); + var typeParameters = ensureTypeParams(input, input.typeParameters); + var ctor = ts.getFirstConstructorWithBody(input); + var parameterProperties = void 0; + if (ctor) { + var oldDiag_1 = getSymbolAccessibilityDiagnostic; + parameterProperties = ts.compact(ts.flatMap(ctor.parameters, function (param) { + if (!ts.hasModifier(param, 92) || shouldStripInternal(param)) + return; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(param); + if (param.name.kind === 75) { + return preserveJsDoc(ts.createProperty(undefined, ensureModifiers(param), param.name, param.questionToken, ensureType(param, param.type), ensureNoInitializer(param)), param); + } + else { + return walkBindingPattern(param.name); + } + function walkBindingPattern(pattern) { + var elems; + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var elem = _a[_i]; + if (ts.isOmittedExpression(elem)) + continue; + if (ts.isBindingPattern(elem.name)) { + elems = ts.concatenate(elems, walkBindingPattern(elem.name)); + } + elems = elems || []; + elems.push(ts.createProperty(undefined, ensureModifiers(param), elem.name, undefined, ensureType(elem, undefined), undefined)); + } + return elems; + } + })); + getSymbolAccessibilityDiagnostic = oldDiag_1; + } + var hasPrivateIdentifier = ts.some(input.members, function (member) { return !!member.name && ts.isPrivateIdentifier(member.name); }); + var privateIdentifier = hasPrivateIdentifier ? [ + ts.createProperty(undefined, undefined, ts.createPrivateIdentifier("#private"), undefined, undefined, undefined) + ] : undefined; + var memberNodes = ts.concatenate(ts.concatenate(privateIdentifier, parameterProperties), ts.visitNodes(input.members, visitDeclarationSubtree)); + var members = ts.createNodeArray(memberNodes); + var extendsClause_1 = ts.getEffectiveBaseTypeNode(input); + if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 100) { + var oldId = input.name ? ts.unescapeLeadingUnderscores(input.name.escapedText) : "default"; + var newId_1 = ts.createOptimisticUniqueName(oldId + "_base"); + getSymbolAccessibilityDiagnostic = function () { return ({ + diagnosticMessage: ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1, + errorNode: extendsClause_1, + typeName: input.name + }); }; + var varDecl = ts.createVariableDeclaration(newId_1, resolver.createTypeOfExpression(extendsClause_1.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined); + var statement = ts.createVariableStatement(needsDeclare ? [ts.createModifier(130)] : [], ts.createVariableDeclarationList([varDecl], 2)); + var heritageClauses = ts.createNodeArray(ts.map(input.heritageClauses, function (clause) { + if (clause.token === 90) { + var oldDiag_2 = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]); + var newClause = ts.updateHeritageClause(clause, ts.map(clause.types, function (t) { return ts.updateExpressionWithTypeArguments(t, ts.visitNodes(t.typeArguments, visitDeclarationSubtree), newId_1); })); + getSymbolAccessibilityDiagnostic = oldDiag_2; + return newClause; + } + return ts.updateHeritageClause(clause, ts.visitNodes(ts.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 100; })), visitDeclarationSubtree)); + })); + return [statement, cleanup(ts.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members))]; + } + else { + var heritageClauses = transformHeritageClauses(input.heritageClauses); + return cleanup(ts.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members)); + } + } + case 225: { + return cleanup(transformVariableStatement(input)); + } + case 248: { + return cleanup(ts.updateEnumDeclaration(input, undefined, ts.createNodeArray(ensureModifiers(input)), input.name, ts.createNodeArray(ts.mapDefined(input.members, function (m) { + if (shouldStripInternal(m)) + return; + var constValue = resolver.getConstantValue(m); + return preserveJsDoc(ts.updateEnumMember(m, m.name, constValue !== undefined ? ts.createLiteral(constValue) : undefined), m); + })))); + } + } + return ts.Debug.assertNever(input, "Unhandled top-level node in declaration emit: " + ts.SyntaxKind[input.kind]); + function cleanup(node) { + if (isEnclosingDeclaration(input)) { + enclosingDeclaration = previousEnclosingDeclaration; + } + if (canProdiceDiagnostic) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + if (input.kind === 249) { + needsDeclare = previousNeedsDeclare; + } + if (node === input) { + return node; + } + return node && ts.setOriginalNode(preserveJsDoc(node, input), input); + } + } + function transformVariableStatement(input) { + if (!ts.forEach(input.declarationList.declarations, getBindingNameVisible)) + return; + var nodes = ts.visitNodes(input.declarationList.declarations, visitDeclarationSubtree); + if (!ts.length(nodes)) + return; + return ts.updateVariableStatement(input, ts.createNodeArray(ensureModifiers(input)), ts.updateVariableDeclarationList(input.declarationList, nodes)); + } + function recreateBindingPattern(d) { + return ts.flatten(ts.mapDefined(d.elements, function (e) { return recreateBindingElement(e); })); + } + function recreateBindingElement(e) { + if (e.kind === 215) { + return; + } + if (e.name) { + if (!getBindingNameVisible(e)) + return; + if (ts.isBindingPattern(e.name)) { + return recreateBindingPattern(e.name); + } + else { + return ts.createVariableDeclaration(e.name, ensureType(e, undefined), undefined); + } + } + } + function checkName(node) { + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNodeName(node); + } + errorNameNode = node.name; + ts.Debug.assert(resolver.isLateBound(ts.getParseTreeNode(node))); + var decl = node; + var entityName = decl.name.expression; + checkEntityNameVisibility(entityName, enclosingDeclaration); + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + errorNameNode = undefined; + } + function shouldStripInternal(node) { + return !!stripInternal && !!node && isInternalDeclaration(node, currentSourceFile); + } + function isScopeMarker(node) { + return ts.isExportAssignment(node) || ts.isExportDeclaration(node); + } + function hasScopeMarker(statements) { + return ts.some(statements, isScopeMarker); + } + function ensureModifiers(node) { + var currentFlags = ts.getModifierFlags(node); + var newFlags = ensureModifierFlags(node); + if (currentFlags === newFlags) { + return node.modifiers; + } + return ts.createModifiersFromModifierFlags(newFlags); + } + function ensureModifierFlags(node) { + var mask = 3071 ^ (4 | 256); + var additions = (needsDeclare && !isAlwaysType(node)) ? 2 : 0; + var parentIsFile = node.parent.kind === 290; + if (!parentIsFile || (isBundledEmit && parentIsFile && ts.isExternalModule(node.parent))) { + mask ^= 2; + additions = 0; + } + return maskModifierFlags(node, mask, additions); + } + function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) { + var accessorType = getTypeAnnotationFromAccessor(node); + if (!accessorType && node !== accessors.firstAccessor) { + accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor); + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor); + } + if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) { + accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor); + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor); + } + return accessorType; + } + function transformHeritageClauses(nodes) { + return ts.createNodeArray(ts.filter(ts.map(nodes, function (clause) { return ts.updateHeritageClause(clause, ts.visitNodes(ts.createNodeArray(ts.filter(clause.types, function (t) { + return ts.isEntityNameExpression(t.expression) || (clause.token === 90 && t.expression.kind === 100); + })), visitDeclarationSubtree)); }), function (clause) { return clause.types && !!clause.types.length; })); + } + } + ts.transformDeclarations = transformDeclarations; + function isAlwaysType(node) { + if (node.kind === 246) { + return true; + } + return false; + } + function maskModifiers(node, modifierMask, modifierAdditions) { + return ts.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions)); + } + function maskModifierFlags(node, modifierMask, modifierAdditions) { + if (modifierMask === void 0) { modifierMask = 3071 ^ 4; } + if (modifierAdditions === void 0) { modifierAdditions = 0; } + var flags = (ts.getModifierFlags(node) & modifierMask) | modifierAdditions; + if (flags & 512 && !(flags & 1)) { + flags ^= 1; + } + if (flags & 512 && flags & 2) { + flags ^= 2; + } + return flags; + } + function getTypeAnnotationFromAccessor(accessor) { + if (accessor) { + return accessor.kind === 163 + ? accessor.type + : accessor.parameters.length > 0 + ? accessor.parameters[0].type + : undefined; + } + } + function canHaveLiteralInitializer(node) { + switch (node.kind) { + case 159: + case 158: + return !ts.hasModifier(node, 8); + case 156: + case 242: + return true; + } + return false; + } + function isPreservedDeclarationStatement(node) { + switch (node.kind) { + case 244: + case 249: + case 253: + case 246: + case 245: + case 247: + case 248: + case 225: + case 254: + case 260: + case 259: + return true; + } + return false; + } + function isProcessedComponent(node) { + switch (node.kind) { + case 166: + case 162: + case 161: + case 163: + case 164: + case 159: + case 158: + case 160: + case 165: + case 167: + case 242: + case 155: + case 216: + case 169: + case 180: + case 170: + case 171: + case 188: + return true; + } + return false; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function getModuleTransformer(moduleKind) { + switch (moduleKind) { + case ts.ModuleKind.ESNext: + case ts.ModuleKind.ES2020: + case ts.ModuleKind.ES2015: + return ts.transformECMAScriptModule; + case ts.ModuleKind.System: + return ts.transformSystemModule; + default: + return ts.transformModule; + } + } + ts.noTransformers = { scriptTransformers: ts.emptyArray, declarationTransformers: ts.emptyArray }; + function getTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles) { + return { + scriptTransformers: getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles), + declarationTransformers: getDeclarationTransformers(customTransformers), + }; + } + ts.getTransformers = getTransformers; + function getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles) { + if (emitOnlyDtsFiles) + return ts.emptyArray; + var jsx = compilerOptions.jsx; + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var transformers = []; + ts.addRange(transformers, customTransformers && ts.map(customTransformers.before, wrapScriptTransformerFactory)); + transformers.push(ts.transformTypeScript); + transformers.push(ts.transformClassFields); + if (jsx === 2) { + transformers.push(ts.transformJsx); + } + if (languageVersion < 99) { + transformers.push(ts.transformESNext); + } + if (languageVersion < 7) { + transformers.push(ts.transformES2020); + } + if (languageVersion < 6) { + transformers.push(ts.transformES2019); + } + if (languageVersion < 5) { + transformers.push(ts.transformES2018); + } + if (languageVersion < 4) { + transformers.push(ts.transformES2017); + } + if (languageVersion < 3) { + transformers.push(ts.transformES2016); + } + if (languageVersion < 2) { + transformers.push(ts.transformES2015); + transformers.push(ts.transformGenerators); + } + transformers.push(getModuleTransformer(moduleKind)); + if (languageVersion < 1) { + transformers.push(ts.transformES5); + } + ts.addRange(transformers, customTransformers && ts.map(customTransformers.after, wrapScriptTransformerFactory)); + return transformers; + } + function getDeclarationTransformers(customTransformers) { + var transformers = []; + transformers.push(ts.transformDeclarations); + ts.addRange(transformers, customTransformers && ts.map(customTransformers.afterDeclarations, wrapDeclarationTransformerFactory)); + return transformers; + } + function wrapCustomTransformer(transformer) { + return function (node) { return ts.isBundle(node) ? transformer.transformBundle(node) : transformer.transformSourceFile(node); }; + } + function wrapCustomTransformerFactory(transformer, handleDefault) { + return function (context) { + var customTransformer = transformer(context); + return typeof customTransformer === "function" + ? handleDefault(customTransformer) + : wrapCustomTransformer(customTransformer); + }; + } + function wrapScriptTransformerFactory(transformer) { + return wrapCustomTransformerFactory(transformer, ts.chainBundle); + } + function wrapDeclarationTransformerFactory(transformer) { + return wrapCustomTransformerFactory(transformer, ts.identity); + } + function noEmitSubstitution(_hint, node) { + return node; + } + ts.noEmitSubstitution = noEmitSubstitution; + function noEmitNotification(hint, node, callback) { + callback(hint, node); + } + ts.noEmitNotification = noEmitNotification; + function transformNodes(resolver, host, options, nodes, transformers, allowDtsFiles) { + var enabledSyntaxKindFeatures = new Array(330); + var lexicalEnvironmentVariableDeclarations; + var lexicalEnvironmentFunctionDeclarations; + var lexicalEnvironmentVariableDeclarationsStack = []; + var lexicalEnvironmentFunctionDeclarationsStack = []; + var lexicalEnvironmentStackOffset = 0; + var lexicalEnvironmentSuspended = false; + var emitHelpers; + var onSubstituteNode = noEmitSubstitution; + var onEmitNode = noEmitNotification; + var state = 0; + var diagnostics = []; + var context = { + getCompilerOptions: function () { return options; }, + getEmitResolver: function () { return resolver; }, + getEmitHost: function () { return host; }, + startLexicalEnvironment: startLexicalEnvironment, + suspendLexicalEnvironment: suspendLexicalEnvironment, + resumeLexicalEnvironment: resumeLexicalEnvironment, + endLexicalEnvironment: endLexicalEnvironment, + hoistVariableDeclaration: hoistVariableDeclaration, + hoistFunctionDeclaration: hoistFunctionDeclaration, + requestEmitHelper: requestEmitHelper, + readEmitHelpers: readEmitHelpers, + enableSubstitution: enableSubstitution, + enableEmitNotification: enableEmitNotification, + isSubstitutionEnabled: isSubstitutionEnabled, + isEmitNotificationEnabled: isEmitNotificationEnabled, + get onSubstituteNode() { return onSubstituteNode; }, + set onSubstituteNode(value) { + ts.Debug.assert(state < 1, "Cannot modify transformation hooks after initialization has completed."); + ts.Debug.assert(value !== undefined, "Value must not be 'undefined'"); + onSubstituteNode = value; + }, + get onEmitNode() { return onEmitNode; }, + set onEmitNode(value) { + ts.Debug.assert(state < 1, "Cannot modify transformation hooks after initialization has completed."); + ts.Debug.assert(value !== undefined, "Value must not be 'undefined'"); + onEmitNode = value; + }, + addDiagnostic: function (diag) { + diagnostics.push(diag); + } + }; + for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) { + var node = nodes_4[_i]; + ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node))); + } + ts.performance.mark("beforeTransform"); + var transformersWithContext = transformers.map(function (t) { return t(context); }); + var transformation = function (node) { + for (var _i = 0, transformersWithContext_1 = transformersWithContext; _i < transformersWithContext_1.length; _i++) { + var transform = transformersWithContext_1[_i]; + node = transform(node); + } + return node; + }; + state = 1; + var transformed = ts.map(nodes, allowDtsFiles ? transformation : transformRoot); + state = 2; + ts.performance.mark("afterTransform"); + ts.performance.measure("transformTime", "beforeTransform", "afterTransform"); + return { + transformed: transformed, + substituteNode: substituteNode, + emitNodeWithNotification: emitNodeWithNotification, + isEmitNotificationEnabled: isEmitNotificationEnabled, + dispose: dispose, + diagnostics: diagnostics + }; + function transformRoot(node) { + return node && (!ts.isSourceFile(node) || !node.isDeclarationFile) ? transformation(node) : node; + } + function enableSubstitution(kind) { + ts.Debug.assert(state < 2, "Cannot modify the transformation context after transformation has completed."); + enabledSyntaxKindFeatures[kind] |= 1; + } + function isSubstitutionEnabled(node) { + return (enabledSyntaxKindFeatures[node.kind] & 1) !== 0 + && (ts.getEmitFlags(node) & 4) === 0; + } + function substituteNode(hint, node) { + ts.Debug.assert(state < 3, "Cannot substitute a node after the result is disposed."); + return node && isSubstitutionEnabled(node) && onSubstituteNode(hint, node) || node; + } + function enableEmitNotification(kind) { + ts.Debug.assert(state < 2, "Cannot modify the transformation context after transformation has completed."); + enabledSyntaxKindFeatures[kind] |= 2; + } + function isEmitNotificationEnabled(node) { + return (enabledSyntaxKindFeatures[node.kind] & 2) !== 0 + || (ts.getEmitFlags(node) & 2) !== 0; + } + function emitNodeWithNotification(hint, node, emitCallback) { + ts.Debug.assert(state < 3, "Cannot invoke TransformationResult callbacks after the result is disposed."); + if (node) { + if (isEmitNotificationEnabled(node)) { + onEmitNode(hint, node, emitCallback); + } + else { + emitCallback(hint, node); + } + } + } + function hoistVariableDeclaration(name) { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + var decl = ts.setEmitFlags(ts.createVariableDeclaration(name), 64); + if (!lexicalEnvironmentVariableDeclarations) { + lexicalEnvironmentVariableDeclarations = [decl]; + } + else { + lexicalEnvironmentVariableDeclarations.push(decl); + } + } + function hoistFunctionDeclaration(func) { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + if (!lexicalEnvironmentFunctionDeclarations) { + lexicalEnvironmentFunctionDeclarations = [func]; + } + else { + lexicalEnvironmentFunctionDeclarations.push(func); + } + } + function startLexicalEnvironment() { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended."); + lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentVariableDeclarations; + lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFunctionDeclarations; + lexicalEnvironmentStackOffset++; + lexicalEnvironmentVariableDeclarations = undefined; + lexicalEnvironmentFunctionDeclarations = undefined; + } + function suspendLexicalEnvironment() { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is already suspended."); + lexicalEnvironmentSuspended = true; + } + function resumeLexicalEnvironment() { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(lexicalEnvironmentSuspended, "Lexical environment is not suspended."); + lexicalEnvironmentSuspended = false; + } + function endLexicalEnvironment() { + ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended."); + var statements; + if (lexicalEnvironmentVariableDeclarations || lexicalEnvironmentFunctionDeclarations) { + if (lexicalEnvironmentFunctionDeclarations) { + statements = __spreadArrays(lexicalEnvironmentFunctionDeclarations); + } + if (lexicalEnvironmentVariableDeclarations) { + var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations)); + ts.setEmitFlags(statement, 1048576); + if (!statements) { + statements = [statement]; + } + else { + statements.push(statement); + } + } + } + lexicalEnvironmentStackOffset--; + lexicalEnvironmentVariableDeclarations = lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset]; + lexicalEnvironmentFunctionDeclarations = lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset]; + if (lexicalEnvironmentStackOffset === 0) { + lexicalEnvironmentVariableDeclarationsStack = []; + lexicalEnvironmentFunctionDeclarationsStack = []; + } + return statements; + } + function requestEmitHelper(helper) { + ts.Debug.assert(state > 0, "Cannot modify the transformation context during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the transformation context after transformation has completed."); + ts.Debug.assert(!helper.scoped, "Cannot request a scoped emit helper."); + emitHelpers = ts.append(emitHelpers, helper); + } + function readEmitHelpers() { + ts.Debug.assert(state > 0, "Cannot modify the transformation context during initialization."); + ts.Debug.assert(state < 2, "Cannot modify the transformation context after transformation has completed."); + var helpers = emitHelpers; + emitHelpers = undefined; + return helpers; + } + function dispose() { + if (state < 3) { + for (var _i = 0, nodes_5 = nodes; _i < nodes_5.length; _i++) { + var node = nodes_5[_i]; + ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node))); + } + lexicalEnvironmentVariableDeclarations = undefined; + lexicalEnvironmentVariableDeclarationsStack = undefined; + lexicalEnvironmentFunctionDeclarations = undefined; + lexicalEnvironmentFunctionDeclarationsStack = undefined; + onSubstituteNode = undefined; + onEmitNode = undefined; + emitHelpers = undefined; + state = 3; + } + } + } + ts.transformNodes = transformNodes; +})(ts || (ts = {})); +var ts; +(function (ts) { + var brackets = createBracketsMap(); + var syntheticParent = { pos: -1, end: -1 }; + function isBuildInfoFile(file) { + return ts.fileExtensionIs(file, ".tsbuildinfo"); + } + ts.isBuildInfoFile = isBuildInfoFile; + function forEachEmittedFile(host, action, sourceFilesOrTargetSourceFile, forceDtsEmit, onlyBuildInfo, includeBuildInfo) { + if (forceDtsEmit === void 0) { forceDtsEmit = false; } + var sourceFiles = ts.isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : ts.getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit); + var options = host.getCompilerOptions(); + if (options.outFile || options.out) { + var prepends = host.getPrependNodes(); + if (sourceFiles.length || prepends.length) { + var bundle = ts.createBundle(sourceFiles, prepends); + var result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle); + if (result) { + return result; + } + } + } + else { + if (!onlyBuildInfo) { + for (var _a = 0, sourceFiles_1 = sourceFiles; _a < sourceFiles_1.length; _a++) { + var sourceFile = sourceFiles_1[_a]; + var result = action(getOutputPathsFor(sourceFile, host, forceDtsEmit), sourceFile); + if (result) { + return result; + } + } + } + if (includeBuildInfo) { + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(host.getCompilerOptions()); + if (buildInfoPath) + return action({ buildInfoPath: buildInfoPath }, undefined); + } + } + } + ts.forEachEmittedFile = forEachEmittedFile; + function getTsBuildInfoEmitOutputFilePath(options) { + var configFile = options.configFilePath; + if (!ts.isIncrementalCompilation(options)) + return undefined; + if (options.tsBuildInfoFile) + return options.tsBuildInfoFile; + var outPath = options.outFile || options.out; + var buildInfoExtensionLess; + if (outPath) { + buildInfoExtensionLess = ts.removeFileExtension(outPath); + } + else { + if (!configFile) + return undefined; + var configFileExtensionLess = ts.removeFileExtension(configFile); + buildInfoExtensionLess = options.outDir ? + options.rootDir ? + ts.resolvePath(options.outDir, ts.getRelativePathFromDirectory(options.rootDir, configFileExtensionLess, true)) : + ts.combinePaths(options.outDir, ts.getBaseFileName(configFileExtensionLess)) : + configFileExtensionLess; + } + return buildInfoExtensionLess + ".tsbuildinfo"; + } + ts.getTsBuildInfoEmitOutputFilePath = getTsBuildInfoEmitOutputFilePath; + function getOutputPathsForBundle(options, forceDtsPaths) { + var outPath = options.outFile || options.out; + var jsFilePath = options.emitDeclarationOnly ? undefined : outPath; + var sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options); + var declarationFilePath = (forceDtsPaths || ts.getEmitDeclarations(options)) ? ts.removeFileExtension(outPath) + ".d.ts" : undefined; + var declarationMapPath = declarationFilePath && ts.getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined; + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(options); + return { jsFilePath: jsFilePath, sourceMapFilePath: sourceMapFilePath, declarationFilePath: declarationFilePath, declarationMapPath: declarationMapPath, buildInfoPath: buildInfoPath }; + } + ts.getOutputPathsForBundle = getOutputPathsForBundle; + function getOutputPathsFor(sourceFile, host, forceDtsPaths) { + var options = host.getCompilerOptions(); + if (sourceFile.kind === 291) { + return getOutputPathsForBundle(options, forceDtsPaths); + } + else { + var ownOutputFilePath = ts.getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options)); + var isJsonFile = ts.isJsonSourceFile(sourceFile); + var isJsonEmittedToSameLocation = isJsonFile && + ts.comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === 0; + var jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? undefined : ownOutputFilePath; + var sourceMapFilePath = !jsFilePath || ts.isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options); + var declarationFilePath = (forceDtsPaths || (ts.getEmitDeclarations(options) && !isJsonFile)) ? ts.getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : undefined; + var declarationMapPath = declarationFilePath && ts.getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined; + return { jsFilePath: jsFilePath, sourceMapFilePath: sourceMapFilePath, declarationFilePath: declarationFilePath, declarationMapPath: declarationMapPath, buildInfoPath: undefined }; + } + } + ts.getOutputPathsFor = getOutputPathsFor; + function getSourceMapFilePath(jsFilePath, options) { + return (options.sourceMap && !options.inlineSourceMap) ? jsFilePath + ".map" : undefined; + } + function getOutputExtension(sourceFile, options) { + if (ts.isJsonSourceFile(sourceFile)) { + return ".json"; + } + if (options.jsx === 1) { + if (ts.isSourceFileJS(sourceFile)) { + if (ts.fileExtensionIs(sourceFile.fileName, ".jsx")) { + return ".jsx"; + } + } + else if (sourceFile.languageVariant === 1) { + return ".jsx"; + } + } + return ".js"; + } + ts.getOutputExtension = getOutputExtension; + function rootDirOfOptions(configFile) { + return configFile.options.rootDir || ts.getDirectoryPath(ts.Debug.assertDefined(configFile.options.configFilePath)); + } + function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir) { + return outputDir ? + ts.resolvePath(outputDir, ts.getRelativePathFromDirectory(rootDirOfOptions(configFile), inputFileName, ignoreCase)) : + inputFileName; + } + function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase) { + ts.Debug.assert(!ts.fileExtensionIs(inputFileName, ".d.ts") && !ts.fileExtensionIs(inputFileName, ".json")); + return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir), ".d.ts"); + } + ts.getOutputDeclarationFileName = getOutputDeclarationFileName; + function getOutputJSFileName(inputFileName, configFile, ignoreCase) { + if (configFile.options.emitDeclarationOnly) + return undefined; + var isJsonFile = ts.fileExtensionIs(inputFileName, ".json"); + var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir), isJsonFile ? + ".json" : + ts.fileExtensionIs(inputFileName, ".tsx") && configFile.options.jsx === 1 ? + ".jsx" : + ".js"); + return !isJsonFile || ts.comparePaths(inputFileName, outputFileName, ts.Debug.assertDefined(configFile.options.configFilePath), ignoreCase) !== 0 ? + outputFileName : + undefined; + } + function createAddOutput() { + var outputs; + return { addOutput: addOutput, getOutputs: getOutputs }; + function addOutput(path) { + if (path) { + (outputs || (outputs = [])).push(path); + } + } + function getOutputs() { + return outputs || ts.emptyArray; + } + } + function getSingleOutputFileNames(configFile, addOutput) { + var _a = getOutputPathsForBundle(configFile.options, false), jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + addOutput(jsFilePath); + addOutput(sourceMapFilePath); + addOutput(declarationFilePath); + addOutput(declarationMapPath); + addOutput(buildInfoPath); + } + function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput) { + if (ts.fileExtensionIs(inputFileName, ".d.ts")) + return; + var js = getOutputJSFileName(inputFileName, configFile, ignoreCase); + addOutput(js); + if (ts.fileExtensionIs(inputFileName, ".json")) + return; + if (js && configFile.options.sourceMap) { + addOutput(js + ".map"); + } + if (ts.getEmitDeclarations(configFile.options)) { + var dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase); + addOutput(dts); + if (configFile.options.declarationMap) { + addOutput(dts + ".map"); + } + } + } + function getAllProjectOutputs(configFile, ignoreCase) { + var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs; + if (configFile.options.outFile || configFile.options.out) { + getSingleOutputFileNames(configFile, addOutput); + } + else { + for (var _b = 0, _c = configFile.fileNames; _b < _c.length; _b++) { + var inputFileName = _c[_b]; + getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput); + } + addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options)); + } + return getOutputs(); + } + ts.getAllProjectOutputs = getAllProjectOutputs; + function getOutputFileNames(commandLine, inputFileName, ignoreCase) { + inputFileName = ts.normalizePath(inputFileName); + ts.Debug.assert(ts.contains(commandLine.fileNames, inputFileName), "Expected fileName to be present in command line"); + var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs; + if (commandLine.options.outFile || commandLine.options.out) { + getSingleOutputFileNames(commandLine, addOutput); + } + else { + getOwnOutputFileNames(commandLine, inputFileName, ignoreCase, addOutput); + } + return getOutputs(); + } + ts.getOutputFileNames = getOutputFileNames; + function getFirstProjectOutput(configFile, ignoreCase) { + if (configFile.options.outFile || configFile.options.out) { + var jsFilePath = getOutputPathsForBundle(configFile.options, false).jsFilePath; + return ts.Debug.assertDefined(jsFilePath, "project " + configFile.options.configFilePath + " expected to have at least one output"); + } + for (var _a = 0, _b = configFile.fileNames; _a < _b.length; _a++) { + var inputFileName = _b[_a]; + if (ts.fileExtensionIs(inputFileName, ".d.ts")) + continue; + var jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase); + if (jsFilePath) + return jsFilePath; + if (ts.fileExtensionIs(inputFileName, ".json")) + continue; + if (ts.getEmitDeclarations(configFile.options)) { + return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase); + } + } + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options); + if (buildInfoPath) + return buildInfoPath; + return ts.Debug.fail("project " + configFile.options.configFilePath + " expected to have at least one output"); + } + ts.getFirstProjectOutput = getFirstProjectOutput; + function emitFiles(resolver, host, targetSourceFile, _a, emitOnlyDtsFiles, onlyBuildInfo, forceDtsEmit) { + var scriptTransformers = _a.scriptTransformers, declarationTransformers = _a.declarationTransformers; + var compilerOptions = host.getCompilerOptions(); + var sourceMapDataList = (compilerOptions.sourceMap || compilerOptions.inlineSourceMap || ts.getAreDeclarationMapsEnabled(compilerOptions)) ? [] : undefined; + var emittedFilesList = compilerOptions.listEmittedFiles ? [] : undefined; + var emitterDiagnostics = ts.createDiagnosticCollection(); + var newLine = ts.getNewLineCharacter(compilerOptions, function () { return host.getNewLine(); }); + var writer = ts.createTextWriter(newLine); + var _b = ts.performance.createTimer("printTime", "beforePrint", "afterPrint"), enter = _b.enter, exit = _b.exit; + var bundleBuildInfo; + var emitSkipped = false; + var exportedModulesFromDeclarationEmit; + enter(); + forEachEmittedFile(host, emitSourceFileOrBundle, ts.getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit), forceDtsEmit, onlyBuildInfo, !targetSourceFile); + exit(); + return { + emitSkipped: emitSkipped, + diagnostics: emitterDiagnostics.getDiagnostics(), + emittedFiles: emittedFilesList, + sourceMaps: sourceMapDataList, + exportedModulesFromDeclarationEmit: exportedModulesFromDeclarationEmit + }; + function emitSourceFileOrBundle(_a, sourceFileOrBundle) { + var jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + var buildInfoDirectory; + if (buildInfoPath && sourceFileOrBundle && ts.isBundle(sourceFileOrBundle)) { + buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + bundleBuildInfo = { + commonSourceDirectory: relativeToBuildInfo(host.getCommonSourceDirectory()), + sourceFiles: sourceFileOrBundle.sourceFiles.map(function (file) { return relativeToBuildInfo(ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())); }) + }; + } + emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo); + emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo); + emitBuildInfo(bundleBuildInfo, buildInfoPath); + if (!emitSkipped && emittedFilesList) { + if (!emitOnlyDtsFiles) { + if (jsFilePath) { + emittedFilesList.push(jsFilePath); + } + if (sourceMapFilePath) { + emittedFilesList.push(sourceMapFilePath); + } + if (buildInfoPath) { + emittedFilesList.push(buildInfoPath); + } + } + if (declarationFilePath) { + emittedFilesList.push(declarationFilePath); + } + if (declarationMapPath) { + emittedFilesList.push(declarationMapPath); + } + } + function relativeToBuildInfo(path) { + return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName)); + } + } + function emitBuildInfo(bundle, buildInfoPath) { + if (!buildInfoPath || targetSourceFile || emitSkipped) + return; + var program = host.getProgramBuildInfo(); + if (host.isEmitBlocked(buildInfoPath) || compilerOptions.noEmit) { + emitSkipped = true; + return; + } + var version = ts.version; + ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle: bundle, program: program, version: version }), false); + } + function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) { + if (!sourceFileOrBundle || emitOnlyDtsFiles || !jsFilePath) { + return; + } + if ((jsFilePath && host.isEmitBlocked(jsFilePath)) || compilerOptions.noEmit) { + emitSkipped = true; + return; + } + var transform = ts.transformNodes(resolver, host, compilerOptions, [sourceFileOrBundle], scriptTransformers, false); + var printerOptions = { + removeComments: compilerOptions.removeComments, + newLine: compilerOptions.newLine, + noEmitHelpers: compilerOptions.noEmitHelpers, + module: compilerOptions.module, + target: compilerOptions.target, + sourceMap: compilerOptions.sourceMap, + inlineSourceMap: compilerOptions.inlineSourceMap, + inlineSources: compilerOptions.inlineSources, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + writeBundleFileInfo: !!bundleBuildInfo, + relativeToBuildInfo: relativeToBuildInfo + }; + var printer = createPrinter(printerOptions, { + hasGlobalName: resolver.hasGlobalName, + onEmitNode: transform.emitNodeWithNotification, + isEmitNotificationEnabled: transform.isEmitNotificationEnabled, + substituteNode: transform.substituteNode, + }); + ts.Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform"); + printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform.transformed[0], printer, compilerOptions); + transform.dispose(); + if (bundleBuildInfo) + bundleBuildInfo.js = printer.bundleFileInfo; + } + function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) { + if (!sourceFileOrBundle) + return; + if (!declarationFilePath) { + if (emitOnlyDtsFiles || compilerOptions.emitDeclarationOnly) + emitSkipped = true; + return; + } + var sourceFiles = ts.isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles; + var filesForEmit = forceDtsEmit ? sourceFiles : ts.filter(sourceFiles, ts.isSourceFileNotJson); + var inputListOrBundle = (compilerOptions.outFile || compilerOptions.out) ? [ts.createBundle(filesForEmit, !ts.isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit; + if (emitOnlyDtsFiles && !ts.getEmitDeclarations(compilerOptions)) { + filesForEmit.forEach(collectLinkedAliases); + } + var declarationTransform = ts.transformNodes(resolver, host, compilerOptions, inputListOrBundle, declarationTransformers, false); + if (ts.length(declarationTransform.diagnostics)) { + for (var _a = 0, _b = declarationTransform.diagnostics; _a < _b.length; _a++) { + var diagnostic = _b[_a]; + emitterDiagnostics.add(diagnostic); + } + } + var printerOptions = { + removeComments: compilerOptions.removeComments, + newLine: compilerOptions.newLine, + noEmitHelpers: true, + module: compilerOptions.module, + target: compilerOptions.target, + sourceMap: compilerOptions.sourceMap, + inlineSourceMap: compilerOptions.inlineSourceMap, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + onlyPrintJsDocStyle: true, + writeBundleFileInfo: !!bundleBuildInfo, + recordInternalSection: !!bundleBuildInfo, + relativeToBuildInfo: relativeToBuildInfo + }; + var declarationPrinter = createPrinter(printerOptions, { + hasGlobalName: resolver.hasGlobalName, + onEmitNode: declarationTransform.emitNodeWithNotification, + isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled, + substituteNode: declarationTransform.substituteNode, + }); + var declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit; + emitSkipped = emitSkipped || declBlocked; + if (!declBlocked || forceDtsEmit) { + ts.Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform"); + printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform.transformed[0], declarationPrinter, { + sourceMap: compilerOptions.declarationMap, + sourceRoot: compilerOptions.sourceRoot, + mapRoot: compilerOptions.mapRoot, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + }); + if (forceDtsEmit && declarationTransform.transformed[0].kind === 290) { + var sourceFile = declarationTransform.transformed[0]; + exportedModulesFromDeclarationEmit = sourceFile.exportedModulesFromDeclarationEmit; + } + } + declarationTransform.dispose(); + if (bundleBuildInfo) + bundleBuildInfo.dts = declarationPrinter.bundleFileInfo; + } + function collectLinkedAliases(node) { + if (ts.isExportAssignment(node)) { + if (node.expression.kind === 75) { + resolver.collectLinkedAliases(node.expression, true); + } + return; + } + else if (ts.isExportSpecifier(node)) { + resolver.collectLinkedAliases(node.propertyName || node.name, true); + return; + } + ts.forEachChild(node, collectLinkedAliases); + } + function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle, printer, mapOptions) { + var bundle = sourceFileOrBundle.kind === 291 ? sourceFileOrBundle : undefined; + var sourceFile = sourceFileOrBundle.kind === 290 ? sourceFileOrBundle : undefined; + var sourceFiles = bundle ? bundle.sourceFiles : [sourceFile]; + var sourceMapGenerator; + if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) { + sourceMapGenerator = ts.createSourceMapGenerator(host, ts.getBaseFileName(ts.normalizeSlashes(jsFilePath)), getSourceRoot(mapOptions), getSourceMapDirectory(mapOptions, jsFilePath, sourceFile), mapOptions); + } + if (bundle) { + printer.writeBundle(bundle, writer, sourceMapGenerator); + } + else { + printer.writeFile(sourceFile, writer, sourceMapGenerator); + } + if (sourceMapGenerator) { + if (sourceMapDataList) { + sourceMapDataList.push({ + inputSourceFileNames: sourceMapGenerator.getSources(), + sourceMap: sourceMapGenerator.toJSON() + }); + } + var sourceMappingURL = getSourceMappingURL(mapOptions, sourceMapGenerator, jsFilePath, sourceMapFilePath, sourceFile); + if (sourceMappingURL) { + if (!writer.isAtStartOfLine()) + writer.rawWrite(newLine); + writer.writeComment("//# " + "sourceMappingURL" + "=" + sourceMappingURL); + } + if (sourceMapFilePath) { + var sourceMap = sourceMapGenerator.toString(); + ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles); + } + } + else { + writer.writeLine(); + } + ts.writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles); + writer.clear(); + } + function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) { + return (mapOptions.sourceMap || mapOptions.inlineSourceMap) + && (sourceFileOrBundle.kind !== 290 || !ts.fileExtensionIs(sourceFileOrBundle.fileName, ".json")); + } + function getSourceRoot(mapOptions) { + var sourceRoot = ts.normalizeSlashes(mapOptions.sourceRoot || ""); + return sourceRoot ? ts.ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot; + } + function getSourceMapDirectory(mapOptions, filePath, sourceFile) { + if (mapOptions.sourceRoot) + return host.getCommonSourceDirectory(); + if (mapOptions.mapRoot) { + var sourceMapDir = ts.normalizeSlashes(mapOptions.mapRoot); + if (sourceFile) { + sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir)); + } + if (ts.getRootLength(sourceMapDir) === 0) { + sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + } + return sourceMapDir; + } + return ts.getDirectoryPath(ts.normalizePath(filePath)); + } + function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile) { + if (mapOptions.inlineSourceMap) { + var sourceMapText = sourceMapGenerator.toString(); + var base64SourceMapText = ts.base64encode(ts.sys, sourceMapText); + return "data:application/json;base64," + base64SourceMapText; + } + var sourceMapFile = ts.getBaseFileName(ts.normalizeSlashes(ts.Debug.assertDefined(sourceMapFilePath))); + if (mapOptions.mapRoot) { + var sourceMapDir = ts.normalizeSlashes(mapOptions.mapRoot); + if (sourceFile) { + sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir)); + } + if (ts.getRootLength(sourceMapDir) === 0) { + sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + return ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(filePath)), ts.combinePaths(sourceMapDir, sourceMapFile), host.getCurrentDirectory(), host.getCanonicalFileName, true); + } + else { + return ts.combinePaths(sourceMapDir, sourceMapFile); + } + } + return sourceMapFile; + } + } + ts.emitFiles = emitFiles; + function getBuildInfoText(buildInfo) { + return JSON.stringify(buildInfo, undefined, 2); + } + ts.getBuildInfoText = getBuildInfoText; + function getBuildInfo(buildInfoText) { + return JSON.parse(buildInfoText); + } + ts.getBuildInfo = getBuildInfo; + ts.notImplementedResolver = { + hasGlobalName: ts.notImplemented, + getReferencedExportContainer: ts.notImplemented, + getReferencedImportDeclaration: ts.notImplemented, + getReferencedDeclarationWithCollidingName: ts.notImplemented, + isDeclarationWithCollidingName: ts.notImplemented, + isValueAliasDeclaration: ts.notImplemented, + isReferencedAliasDeclaration: ts.notImplemented, + isTopLevelValueImportEqualsWithEntityName: ts.notImplemented, + getNodeCheckFlags: ts.notImplemented, + isDeclarationVisible: ts.notImplemented, + isLateBound: function (_node) { return false; }, + collectLinkedAliases: ts.notImplemented, + isImplementationOfOverload: ts.notImplemented, + isRequiredInitializedParameter: ts.notImplemented, + isOptionalUninitializedParameterProperty: ts.notImplemented, + isExpandoFunctionDeclaration: ts.notImplemented, + getPropertiesOfContainerFunction: ts.notImplemented, + createTypeOfDeclaration: ts.notImplemented, + createReturnTypeOfSignatureDeclaration: ts.notImplemented, + createTypeOfExpression: ts.notImplemented, + createLiteralConstValue: ts.notImplemented, + isSymbolAccessible: ts.notImplemented, + isEntityNameVisible: ts.notImplemented, + getConstantValue: ts.notImplemented, + getReferencedValueDeclaration: ts.notImplemented, + getTypeReferenceSerializationKind: ts.notImplemented, + isOptionalParameter: ts.notImplemented, + moduleExportsSomeValue: ts.notImplemented, + isArgumentsLocalBinding: ts.notImplemented, + getExternalModuleFileFromDeclaration: ts.notImplemented, + getTypeReferenceDirectivesForEntityName: ts.notImplemented, + getTypeReferenceDirectivesForSymbol: ts.notImplemented, + isLiteralConstDeclaration: ts.notImplemented, + getJsxFactoryEntity: ts.notImplemented, + getAllAccessorDeclarations: ts.notImplemented, + getSymbolOfExternalModuleSpecifier: ts.notImplemented, + isBindingCapturedByNode: ts.notImplemented, + getDeclarationStatementsForSourceFile: ts.notImplemented, + }; + function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host) { + var sourceFiles = bundle.sourceFiles.map(function (fileName) { + var sourceFile = ts.createNode(290, 0, 0); + sourceFile.fileName = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), ts.getNormalizedAbsolutePath(fileName, buildInfoDirectory), !host.useCaseSensitiveFileNames()); + sourceFile.text = ""; + sourceFile.statements = ts.createNodeArray(); + return sourceFile; + }); + var jsBundle = ts.Debug.assertDefined(bundle.js); + ts.forEach(jsBundle.sources && jsBundle.sources.prologues, function (prologueInfo) { + var sourceFile = sourceFiles[prologueInfo.file]; + sourceFile.text = prologueInfo.text; + sourceFile.end = prologueInfo.text.length; + sourceFile.statements = ts.createNodeArray(prologueInfo.directives.map(function (directive) { + var statement = ts.createNode(226, directive.pos, directive.end); + statement.expression = ts.createNode(10, directive.expression.pos, directive.expression.end); + statement.expression.text = directive.expression.text; + return statement; + })); + }); + return sourceFiles; + } + function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) { + var _a = getOutputPathsForBundle(config.options, false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath; + var buildInfoText = host.readFile(ts.Debug.assertDefined(buildInfoPath)); + if (!buildInfoText) + return buildInfoPath; + var jsFileText = host.readFile(ts.Debug.assertDefined(jsFilePath)); + if (!jsFileText) + return jsFilePath; + var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath); + if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap) + return sourceMapFilePath || "inline sourcemap decoding"; + var declarationText = declarationFilePath && host.readFile(declarationFilePath); + if (declarationFilePath && !declarationText) + return declarationFilePath; + var declarationMapText = declarationMapPath && host.readFile(declarationMapPath); + if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap) + return declarationMapPath || "inline sourcemap decoding"; + var buildInfo = getBuildInfo(buildInfoText); + if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationText && !buildInfo.bundle.dts)) + return buildInfoPath; + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, true); + var outputFiles = []; + var prependNodes = ts.createPrependNodes(config.projectReferences, getCommandLine, function (f) { return host.readFile(f); }); + var sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host); + var emitHost = { + getPrependNodes: ts.memoize(function () { return __spreadArrays(prependNodes, [ownPrependInput]); }), + getCanonicalFileName: host.getCanonicalFileName, + getCommonSourceDirectory: function () { return ts.getNormalizedAbsolutePath(buildInfo.bundle.commonSourceDirectory, buildInfoDirectory); }, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + getNewLine: function () { return host.getNewLine(); }, + getSourceFile: ts.returnUndefined, + getSourceFileByPath: ts.returnUndefined, + getSourceFiles: function () { return sourceFilesForJsEmit; }, + getLibFileFromReference: ts.notImplemented, + isSourceFileFromExternalLibrary: ts.returnFalse, + getResolvedProjectReferenceToRedirect: ts.returnUndefined, + isSourceOfProjectReferenceRedirect: ts.returnFalse, + writeFile: function (name, text, writeByteOrderMark) { + switch (name) { + case jsFilePath: + if (jsFileText === text) + return; + break; + case sourceMapFilePath: + if (sourceMapText === text) + return; + break; + case buildInfoPath: + var newBuildInfo = getBuildInfo(text); + newBuildInfo.program = buildInfo.program; + var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles; + newBuildInfo.bundle.js.sources = js.sources; + if (dts) { + newBuildInfo.bundle.dts.sources = dts.sources; + } + newBuildInfo.bundle.sourceFiles = sourceFiles; + outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark }); + return; + case declarationFilePath: + if (declarationText === text) + return; + break; + case declarationMapPath: + if (declarationMapText === text) + return; + break; + default: + ts.Debug.fail("Unexpected path: " + name); + } + outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); + }, + isEmitBlocked: ts.returnFalse, + readFile: function (f) { return host.readFile(f); }, + fileExists: function (f) { return host.fileExists(f); }, + directoryExists: host.directoryExists && (function (f) { return host.directoryExists(f); }), + useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, + getProgramBuildInfo: ts.returnUndefined, + getSourceFileFromReference: ts.returnUndefined, + redirectTargetsMap: ts.createMultiMap() + }; + emitFiles(ts.notImplementedResolver, emitHost, undefined, ts.getTransformers(config.options, customTransformers)); + return outputFiles; + } + ts.emitUsingBuildInfo = emitUsingBuildInfo; + function createPrinter(printerOptions, handlers) { + if (printerOptions === void 0) { printerOptions = {}; } + if (handlers === void 0) { handlers = {}; } + var hasGlobalName = handlers.hasGlobalName, _a = handlers.onEmitNode, onEmitNode = _a === void 0 ? ts.noEmitNotification : _a, isEmitNotificationEnabled = handlers.isEmitNotificationEnabled, _b = handlers.substituteNode, substituteNode = _b === void 0 ? ts.noEmitSubstitution : _b, onBeforeEmitNodeArray = handlers.onBeforeEmitNodeArray, onAfterEmitNodeArray = handlers.onAfterEmitNodeArray, onBeforeEmitToken = handlers.onBeforeEmitToken, onAfterEmitToken = handlers.onAfterEmitToken; + var extendedDiagnostics = !!printerOptions.extendedDiagnostics; + var newLine = ts.getNewLineCharacter(printerOptions); + var moduleKind = ts.getEmitModuleKind(printerOptions); + var bundledHelpers = ts.createMap(); + var currentSourceFile; + var nodeIdToGeneratedName; + var autoGeneratedIdToGeneratedName; + var generatedNames; + var tempFlagsStack; + var tempFlags; + var reservedNamesStack; + var reservedNames; + var writer; + var ownWriter; + var write = writeBase; + var isOwnFileEmit; + var bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : undefined; + var relativeToBuildInfo = bundleFileInfo ? ts.Debug.assertDefined(printerOptions.relativeToBuildInfo) : undefined; + var recordInternalSection = printerOptions.recordInternalSection; + var sourceFileTextPos = 0; + var sourceFileTextKind = "text"; + var sourceMapsDisabled = true; + var sourceMapGenerator; + var sourceMapSource; + var sourceMapSourceIndex = -1; + var containerPos = -1; + var containerEnd = -1; + var declarationListContainerEnd = -1; + var currentLineMap; + var detachedCommentsInfo; + var hasWrittenComment = false; + var commentsDisabled = !!printerOptions.removeComments; + var lastNode; + var lastSubstitution; + var _c = ts.performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment"), enterComment = _c.enter, exitComment = _c.exit; + reset(); + return { + printNode: printNode, + printList: printList, + printFile: printFile, + printBundle: printBundle, + writeNode: writeNode, + writeList: writeList, + writeFile: writeFile, + writeBundle: writeBundle, + bundleFileInfo: bundleFileInfo + }; + function printNode(hint, node, sourceFile) { + switch (hint) { + case 0: + ts.Debug.assert(ts.isSourceFile(node), "Expected a SourceFile node."); + break; + case 2: + ts.Debug.assert(ts.isIdentifier(node), "Expected an Identifier node."); + break; + case 1: + ts.Debug.assert(ts.isExpression(node), "Expected an Expression node."); + break; + } + switch (node.kind) { + case 290: return printFile(node); + case 291: return printBundle(node); + case 292: return printUnparsedSource(node); + } + writeNode(hint, node, sourceFile, beginPrint()); + return endPrint(); + } + function printList(format, nodes, sourceFile) { + writeList(format, nodes, sourceFile, beginPrint()); + return endPrint(); + } + function printBundle(bundle) { + writeBundle(bundle, beginPrint(), undefined); + return endPrint(); + } + function printFile(sourceFile) { + writeFile(sourceFile, beginPrint(), undefined); + return endPrint(); + } + function printUnparsedSource(unparsed) { + writeUnparsedSource(unparsed, beginPrint()); + return endPrint(); + } + function writeNode(hint, node, sourceFile, output) { + var previousWriter = writer; + setWriter(output, undefined); + print(hint, node, sourceFile); + reset(); + writer = previousWriter; + } + function writeList(format, nodes, sourceFile, output) { + var previousWriter = writer; + setWriter(output, undefined); + if (sourceFile) { + setSourceFile(sourceFile); + } + emitList(syntheticParent, nodes, format); + reset(); + writer = previousWriter; + } + function getTextPosWithWriteLine() { + return writer.getTextPosWithWriteLine ? writer.getTextPosWithWriteLine() : writer.getTextPos(); + } + function updateOrPushBundleFileTextLike(pos, end, kind) { + var last = ts.lastOrUndefined(bundleFileInfo.sections); + if (last && last.kind === kind) { + last.end = end; + } + else { + bundleFileInfo.sections.push({ pos: pos, end: end, kind: kind }); + } + } + function recordBundleFileInternalSectionStart(node) { + if (recordInternalSection && + bundleFileInfo && + currentSourceFile && + (ts.isDeclaration(node) || ts.isVariableStatement(node)) && + ts.isInternalDeclaration(node, currentSourceFile) && + sourceFileTextKind !== "internal") { + var prevSourceFileTextKind = sourceFileTextKind; + recordBundleFileTextLikeSection(writer.getTextPos()); + sourceFileTextPos = getTextPosWithWriteLine(); + sourceFileTextKind = "internal"; + return prevSourceFileTextKind; + } + return undefined; + } + function recordBundleFileInternalSectionEnd(prevSourceFileTextKind) { + if (prevSourceFileTextKind) { + recordBundleFileTextLikeSection(writer.getTextPos()); + sourceFileTextPos = getTextPosWithWriteLine(); + sourceFileTextKind = prevSourceFileTextKind; + } + } + function recordBundleFileTextLikeSection(end) { + if (sourceFileTextPos < end) { + updateOrPushBundleFileTextLike(sourceFileTextPos, end, sourceFileTextKind); + return true; + } + return false; + } + function writeBundle(bundle, output, sourceMapGenerator) { + var _a; + isOwnFileEmit = false; + var previousWriter = writer; + setWriter(output, sourceMapGenerator); + emitShebangIfNeeded(bundle); + emitPrologueDirectivesIfNeeded(bundle); + emitHelpers(bundle); + emitSyntheticTripleSlashReferencesIfNeeded(bundle); + for (var _b = 0, _c = bundle.prepends; _b < _c.length; _b++) { + var prepend = _c[_b]; + writeLine(); + var pos = writer.getTextPos(); + var savedSections = bundleFileInfo && bundleFileInfo.sections; + if (savedSections) + bundleFileInfo.sections = []; + print(4, prepend, undefined); + if (bundleFileInfo) { + var newSections = bundleFileInfo.sections; + bundleFileInfo.sections = savedSections; + if (prepend.oldFileOfCurrentEmit) + (_a = bundleFileInfo.sections).push.apply(_a, newSections); + else { + newSections.forEach(function (section) { return ts.Debug.assert(ts.isBundleFileTextLike(section)); }); + bundleFileInfo.sections.push({ + pos: pos, + end: writer.getTextPos(), + kind: "prepend", + data: relativeToBuildInfo(prepend.fileName), + texts: newSections + }); + } + } + } + sourceFileTextPos = getTextPosWithWriteLine(); + for (var _d = 0, _e = bundle.sourceFiles; _d < _e.length; _d++) { + var sourceFile = _e[_d]; + print(0, sourceFile, sourceFile); + } + if (bundleFileInfo && bundle.sourceFiles.length) { + var end = writer.getTextPos(); + if (recordBundleFileTextLikeSection(end)) { + var prologues = getPrologueDirectivesFromBundledSourceFiles(bundle); + if (prologues) { + if (!bundleFileInfo.sources) + bundleFileInfo.sources = {}; + bundleFileInfo.sources.prologues = prologues; + } + var helpers = getHelpersFromBundledSourceFiles(bundle); + if (helpers) { + if (!bundleFileInfo.sources) + bundleFileInfo.sources = {}; + bundleFileInfo.sources.helpers = helpers; + } + } + } + reset(); + writer = previousWriter; + } + function writeUnparsedSource(unparsed, output) { + var previousWriter = writer; + setWriter(output, undefined); + print(4, unparsed, undefined); + reset(); + writer = previousWriter; + } + function writeFile(sourceFile, output, sourceMapGenerator) { + isOwnFileEmit = true; + var previousWriter = writer; + setWriter(output, sourceMapGenerator); + emitShebangIfNeeded(sourceFile); + emitPrologueDirectivesIfNeeded(sourceFile); + print(0, sourceFile, sourceFile); + reset(); + writer = previousWriter; + } + function beginPrint() { + return ownWriter || (ownWriter = ts.createTextWriter(newLine)); + } + function endPrint() { + var text = ownWriter.getText(); + ownWriter.clear(); + return text; + } + function print(hint, node, sourceFile) { + if (sourceFile) { + setSourceFile(sourceFile); + } + pipelineEmit(hint, node); + } + function setSourceFile(sourceFile) { + currentSourceFile = sourceFile; + currentLineMap = undefined; + detachedCommentsInfo = undefined; + if (sourceFile) { + setSourceMapSource(sourceFile); + } + } + function setWriter(_writer, _sourceMapGenerator) { + if (_writer && printerOptions.omitTrailingSemicolon) { + _writer = ts.getTrailingSemicolonDeferringWriter(_writer); + } + writer = _writer; + sourceMapGenerator = _sourceMapGenerator; + sourceMapsDisabled = !writer || !sourceMapGenerator; + } + function reset() { + nodeIdToGeneratedName = []; + autoGeneratedIdToGeneratedName = []; + generatedNames = ts.createMap(); + tempFlagsStack = []; + tempFlags = 0; + reservedNamesStack = []; + currentSourceFile = undefined; + currentLineMap = undefined; + detachedCommentsInfo = undefined; + lastNode = undefined; + lastSubstitution = undefined; + setWriter(undefined, undefined); + } + function getCurrentLineMap() { + return currentLineMap || (currentLineMap = ts.getLineStarts(currentSourceFile)); + } + function emit(node) { + if (node === undefined) + return; + var prevSourceFileTextKind = recordBundleFileInternalSectionStart(node); + var substitute = pipelineEmit(4, node); + recordBundleFileInternalSectionEnd(prevSourceFileTextKind); + return substitute; + } + function emitIdentifierName(node) { + if (node === undefined) + return; + return pipelineEmit(2, node); + } + function emitExpression(node) { + if (node === undefined) + return; + return pipelineEmit(1, node); + } + function emitJsxAttributeValue(node) { + return pipelineEmit(ts.isStringLiteral(node) ? 6 : 4, node); + } + function pipelineEmit(emitHint, node) { + var savedLastNode = lastNode; + var savedLastSubstitution = lastSubstitution; + lastNode = node; + lastSubstitution = undefined; + var pipelinePhase = getPipelinePhase(0, emitHint, node); + pipelinePhase(emitHint, node); + ts.Debug.assert(lastNode === node); + var substitute = lastSubstitution; + lastNode = savedLastNode; + lastSubstitution = savedLastSubstitution; + return substitute || node; + } + function getPipelinePhase(phase, emitHint, node) { + switch (phase) { + case 0: + if (onEmitNode !== ts.noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) { + return pipelineEmitWithNotification; + } + case 1: + if (substituteNode !== ts.noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node)) !== node) { + return pipelineEmitWithSubstitution; + } + case 2: + if (!commentsDisabled && node.kind !== 290) { + return pipelineEmitWithComments; + } + case 3: + if (!sourceMapsDisabled && node.kind !== 290 && !ts.isInJsonFile(node)) { + return pipelineEmitWithSourceMap; + } + case 4: + return pipelineEmitWithHint; + default: + return ts.Debug.assertNever(phase); + } + } + function getNextPipelinePhase(currentPhase, emitHint, node) { + return getPipelinePhase(currentPhase + 1, emitHint, node); + } + function pipelineEmitWithNotification(hint, node) { + ts.Debug.assert(lastNode === node); + var pipelinePhase = getNextPipelinePhase(0, hint, node); + onEmitNode(hint, node, pipelinePhase); + ts.Debug.assert(lastNode === node); + } + function pipelineEmitWithHint(hint, node) { + ts.Debug.assert(lastNode === node || lastSubstitution === node); + if (hint === 0) + return emitSourceFile(ts.cast(node, ts.isSourceFile)); + if (hint === 2) + return emitIdentifier(ts.cast(node, ts.isIdentifier)); + if (hint === 6) + return emitLiteral(ts.cast(node, ts.isStringLiteral), true); + if (hint === 3) + return emitMappedTypeParameter(ts.cast(node, ts.isTypeParameterDeclaration)); + if (hint === 5) { + ts.Debug.assertNode(node, ts.isEmptyStatement); + return emitEmptyStatement(true); + } + if (hint === 4) { + if (ts.isKeyword(node.kind)) + return writeTokenNode(node, writeKeyword); + switch (node.kind) { + case 15: + case 16: + case 17: + return emitLiteral(node, false); + case 292: + case 286: + return emitUnparsedSourceOrPrepend(node); + case 285: + return writeUnparsedNode(node); + case 287: + case 288: + return emitUnparsedTextLike(node); + case 289: + return emitUnparsedSyntheticReference(node); + case 75: + return emitIdentifier(node); + case 76: + return emitPrivateIdentifier(node); + case 153: + return emitQualifiedName(node); + case 154: + return emitComputedPropertyName(node); + case 155: + return emitTypeParameter(node); + case 156: + return emitParameter(node); + case 157: + return emitDecorator(node); + case 158: + return emitPropertySignature(node); + case 159: + return emitPropertyDeclaration(node); + case 160: + return emitMethodSignature(node); + case 161: + return emitMethodDeclaration(node); + case 162: + return emitConstructor(node); + case 163: + case 164: + return emitAccessorDeclaration(node); + case 165: + return emitCallSignature(node); + case 166: + return emitConstructSignature(node); + case 167: + return emitIndexSignature(node); + case 168: + return emitTypePredicate(node); + case 169: + return emitTypeReference(node); + case 170: + return emitFunctionType(node); + case 300: + return emitJSDocFunctionType(node); + case 171: + return emitConstructorType(node); + case 172: + return emitTypeQuery(node); + case 173: + return emitTypeLiteral(node); + case 174: + return emitArrayType(node); + case 175: + return emitTupleType(node); + case 176: + return emitOptionalType(node); + case 178: + return emitUnionType(node); + case 179: + return emitIntersectionType(node); + case 180: + return emitConditionalType(node); + case 181: + return emitInferType(node); + case 182: + return emitParenthesizedType(node); + case 216: + return emitExpressionWithTypeArguments(node); + case 183: + return emitThisType(); + case 184: + return emitTypeOperator(node); + case 185: + return emitIndexedAccessType(node); + case 186: + return emitMappedType(node); + case 187: + return emitLiteralType(node); + case 188: + return emitImportTypeNode(node); + case 295: + writePunctuation("*"); + return; + case 296: + writePunctuation("?"); + return; + case 297: + return emitJSDocNullableType(node); + case 298: + return emitJSDocNonNullableType(node); + case 299: + return emitJSDocOptionalType(node); + case 177: + case 301: + return emitRestOrJSDocVariadicType(node); + case 189: + return emitObjectBindingPattern(node); + case 190: + return emitArrayBindingPattern(node); + case 191: + return emitBindingElement(node); + case 221: + return emitTemplateSpan(node); + case 222: + return emitSemicolonClassElement(); + case 223: + return emitBlock(node); + case 225: + return emitVariableStatement(node); + case 224: + return emitEmptyStatement(false); + case 226: + return emitExpressionStatement(node); + case 227: + return emitIfStatement(node); + case 228: + return emitDoStatement(node); + case 229: + return emitWhileStatement(node); + case 230: + return emitForStatement(node); + case 231: + return emitForInStatement(node); + case 232: + return emitForOfStatement(node); + case 233: + return emitContinueStatement(node); + case 234: + return emitBreakStatement(node); + case 235: + return emitReturnStatement(node); + case 236: + return emitWithStatement(node); + case 237: + return emitSwitchStatement(node); + case 238: + return emitLabeledStatement(node); + case 239: + return emitThrowStatement(node); + case 240: + return emitTryStatement(node); + case 241: + return emitDebuggerStatement(node); + case 242: + return emitVariableDeclaration(node); + case 243: + return emitVariableDeclarationList(node); + case 244: + return emitFunctionDeclaration(node); + case 245: + return emitClassDeclaration(node); + case 246: + return emitInterfaceDeclaration(node); + case 247: + return emitTypeAliasDeclaration(node); + case 248: + return emitEnumDeclaration(node); + case 249: + return emitModuleDeclaration(node); + case 250: + return emitModuleBlock(node); + case 251: + return emitCaseBlock(node); + case 252: + return emitNamespaceExportDeclaration(node); + case 253: + return emitImportEqualsDeclaration(node); + case 254: + return emitImportDeclaration(node); + case 255: + return emitImportClause(node); + case 256: + return emitNamespaceImport(node); + case 262: + return emitNamespaceExport(node); + case 257: + return emitNamedImports(node); + case 258: + return emitImportSpecifier(node); + case 259: + return emitExportAssignment(node); + case 260: + return emitExportDeclaration(node); + case 261: + return emitNamedExports(node); + case 263: + return emitExportSpecifier(node); + case 264: + return; + case 265: + return emitExternalModuleReference(node); + case 11: + return emitJsxText(node); + case 268: + case 271: + return emitJsxOpeningElementOrFragment(node); + case 269: + case 272: + return emitJsxClosingElementOrFragment(node); + case 273: + return emitJsxAttribute(node); + case 274: + return emitJsxAttributes(node); + case 275: + return emitJsxSpreadAttribute(node); + case 276: + return emitJsxExpression(node); + case 277: + return emitCaseClause(node); + case 278: + return emitDefaultClause(node); + case 279: + return emitHeritageClause(node); + case 280: + return emitCatchClause(node); + case 281: + return emitPropertyAssignment(node); + case 282: + return emitShorthandPropertyAssignment(node); + case 283: + return emitSpreadAssignment(node); + case 284: + return emitEnumMember(node); + case 316: + case 322: + return emitJSDocPropertyLikeTag(node); + case 317: + case 319: + case 318: + case 315: + return emitJSDocSimpleTypedTag(node); + case 307: + return emitJSDocAugmentsTag(node); + case 320: + return emitJSDocTemplateTag(node); + case 321: + return emitJSDocTypedefTag(node); + case 314: + return emitJSDocCallbackTag(node); + case 305: + return emitJSDocSignature(node); + case 304: + return emitJSDocTypeLiteral(node); + case 309: + case 306: + return emitJSDocSimpleTag(node); + case 303: + return emitJSDoc(node); + } + if (ts.isExpression(node)) { + hint = 1; + if (substituteNode !== ts.noEmitSubstitution) { + lastSubstitution = node = substituteNode(hint, node); + } + } + else if (ts.isToken(node)) { + return writeTokenNode(node, writePunctuation); + } + } + if (hint === 1) { + switch (node.kind) { + case 8: + case 9: + return emitNumericOrBigIntLiteral(node); + case 10: + case 13: + case 14: + return emitLiteral(node, false); + case 75: + return emitIdentifier(node); + case 91: + case 100: + case 102: + case 106: + case 104: + case 96: + writeTokenNode(node, writeKeyword); + return; + case 192: + return emitArrayLiteralExpression(node); + case 193: + return emitObjectLiteralExpression(node); + case 194: + return emitPropertyAccessExpression(node); + case 195: + return emitElementAccessExpression(node); + case 196: + return emitCallExpression(node); + case 197: + return emitNewExpression(node); + case 198: + return emitTaggedTemplateExpression(node); + case 199: + return emitTypeAssertionExpression(node); + case 200: + return emitParenthesizedExpression(node); + case 201: + return emitFunctionExpression(node); + case 202: + return emitArrowFunction(node); + case 203: + return emitDeleteExpression(node); + case 204: + return emitTypeOfExpression(node); + case 205: + return emitVoidExpression(node); + case 206: + return emitAwaitExpression(node); + case 207: + return emitPrefixUnaryExpression(node); + case 208: + return emitPostfixUnaryExpression(node); + case 209: + return emitBinaryExpression(node); + case 210: + return emitConditionalExpression(node); + case 211: + return emitTemplateExpression(node); + case 212: + return emitYieldExpression(node); + case 213: + return emitSpreadExpression(node); + case 214: + return emitClassExpression(node); + case 215: + return; + case 217: + return emitAsExpression(node); + case 218: + return emitNonNullExpression(node); + case 219: + return emitMetaProperty(node); + case 266: + return emitJsxElement(node); + case 267: + return emitJsxSelfClosingElement(node); + case 270: + return emitJsxFragment(node); + case 325: + return emitPartiallyEmittedExpression(node); + case 326: + return emitCommaList(node); + } + } + } + function emitMappedTypeParameter(node) { + emit(node.name); + writeSpace(); + writeKeyword("in"); + writeSpace(); + emit(node.constraint); + } + function pipelineEmitWithSubstitution(hint, node) { + ts.Debug.assert(lastNode === node || lastSubstitution === node); + var pipelinePhase = getNextPipelinePhase(1, hint, node); + pipelinePhase(hint, lastSubstitution); + ts.Debug.assert(lastNode === node || lastSubstitution === node); + } + function getHelpersFromBundledSourceFiles(bundle) { + var result; + if (moduleKind === ts.ModuleKind.None || printerOptions.noEmitHelpers) { + return undefined; + } + var bundledHelpers = ts.createMap(); + for (var _a = 0, _b = bundle.sourceFiles; _a < _b.length; _a++) { + var sourceFile = _b[_a]; + var shouldSkip = ts.getExternalHelpersModuleName(sourceFile) !== undefined; + var helpers = getSortedEmitHelpers(sourceFile); + if (!helpers) + continue; + for (var _c = 0, helpers_4 = helpers; _c < helpers_4.length; _c++) { + var helper = helpers_4[_c]; + if (!helper.scoped && !shouldSkip && !bundledHelpers.get(helper.name)) { + bundledHelpers.set(helper.name, true); + (result || (result = [])).push(helper.name); + } + } + } + return result; + } + function emitHelpers(node) { + var helpersEmitted = false; + var bundle = node.kind === 291 ? node : undefined; + if (bundle && moduleKind === ts.ModuleKind.None) { + return; + } + var numPrepends = bundle ? bundle.prepends.length : 0; + var numNodes = bundle ? bundle.sourceFiles.length + numPrepends : 1; + for (var i = 0; i < numNodes; i++) { + var currentNode = bundle ? i < numPrepends ? bundle.prepends[i] : bundle.sourceFiles[i - numPrepends] : node; + var sourceFile = ts.isSourceFile(currentNode) ? currentNode : ts.isUnparsedSource(currentNode) ? undefined : currentSourceFile; + var shouldSkip = printerOptions.noEmitHelpers || (!!sourceFile && ts.hasRecordedExternalHelpers(sourceFile)); + var shouldBundle = (ts.isSourceFile(currentNode) || ts.isUnparsedSource(currentNode)) && !isOwnFileEmit; + var helpers = ts.isUnparsedSource(currentNode) ? currentNode.helpers : getSortedEmitHelpers(currentNode); + if (helpers) { + for (var _a = 0, helpers_5 = helpers; _a < helpers_5.length; _a++) { + var helper = helpers_5[_a]; + if (!helper.scoped) { + if (shouldSkip) + continue; + if (shouldBundle) { + if (bundledHelpers.get(helper.name)) { + continue; + } + bundledHelpers.set(helper.name, true); + } + } + else if (bundle) { + continue; + } + var pos = getTextPosWithWriteLine(); + if (typeof helper.text === "string") { + writeLines(helper.text); + } + else { + writeLines(helper.text(makeFileLevelOptimisticUniqueName)); + } + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "emitHelpers", data: helper.name }); + helpersEmitted = true; + } + } + } + return helpersEmitted; + } + function getSortedEmitHelpers(node) { + var helpers = ts.getEmitHelpers(node); + return helpers && ts.stableSort(helpers, ts.compareEmitHelpers); + } + function emitNumericOrBigIntLiteral(node) { + emitLiteral(node, false); + } + function emitLiteral(node, jsxAttributeEscape) { + var text = getLiteralTextOfNode(node, printerOptions.neverAsciiEscape, jsxAttributeEscape); + if ((printerOptions.sourceMap || printerOptions.inlineSourceMap) + && (node.kind === 10 || ts.isTemplateLiteralKind(node.kind))) { + writeLiteral(text); + } + else { + writeStringLiteral(text); + } + } + function emitUnparsedSourceOrPrepend(unparsed) { + for (var _a = 0, _b = unparsed.texts; _a < _b.length; _a++) { + var text = _b[_a]; + writeLine(); + emit(text); + } + } + function writeUnparsedNode(unparsed) { + writer.rawWrite(unparsed.parent.text.substring(unparsed.pos, unparsed.end)); + } + function emitUnparsedTextLike(unparsed) { + var pos = getTextPosWithWriteLine(); + writeUnparsedNode(unparsed); + if (bundleFileInfo) { + updateOrPushBundleFileTextLike(pos, writer.getTextPos(), unparsed.kind === 287 ? + "text" : + "internal"); + } + } + function emitUnparsedSyntheticReference(unparsed) { + var pos = getTextPosWithWriteLine(); + writeUnparsedNode(unparsed); + if (bundleFileInfo) { + var section = ts.clone(unparsed.section); + section.pos = pos; + section.end = writer.getTextPos(); + bundleFileInfo.sections.push(section); + } + } + function emitIdentifier(node) { + var writeText = node.symbol ? writeSymbol : write; + writeText(getTextOfNode(node, false), node.symbol); + emitList(node, node.typeArguments, 53776); + } + function emitPrivateIdentifier(node) { + var writeText = node.symbol ? writeSymbol : write; + writeText(getTextOfNode(node, false), node.symbol); + } + function emitQualifiedName(node) { + emitEntityName(node.left); + writePunctuation("."); + emit(node.right); + } + function emitEntityName(node) { + if (node.kind === 75) { + emitExpression(node); + } + else { + emit(node); + } + } + function emitComputedPropertyName(node) { + writePunctuation("["); + emitExpression(node.expression); + writePunctuation("]"); + } + function emitTypeParameter(node) { + emit(node.name); + if (node.constraint) { + writeSpace(); + writeKeyword("extends"); + writeSpace(); + emit(node.constraint); + } + if (node.default) { + writeSpace(); + writeOperator("="); + writeSpace(); + emit(node.default); + } + } + function emitParameter(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emit(node.dotDotDotToken); + emitNodeWithWriter(node.name, writeParameter); + emit(node.questionToken); + if (node.parent && node.parent.kind === 300 && !node.name) { + emit(node.type); + } + else { + emitTypeAnnotation(node.type); + } + emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name ? node.name.end : node.modifiers ? node.modifiers.end : node.decorators ? node.decorators.end : node.pos, node); + } + function emitDecorator(decorator) { + writePunctuation("@"); + emitExpression(decorator.expression); + } + function emitPropertySignature(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emitNodeWithWriter(node.name, writeProperty); + emit(node.questionToken); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + } + function emitPropertyDeclaration(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emit(node.name); + emit(node.questionToken); + emit(node.exclamationToken); + emitTypeAnnotation(node.type); + emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name.end, node); + writeTrailingSemicolon(); + } + function emitMethodSignature(node) { + pushNameGenerationScope(node); + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emit(node.name); + emit(node.questionToken); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitMethodDeclaration(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emit(node.asteriskToken); + emit(node.name); + emit(node.questionToken); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitConstructor(node) { + emitModifiers(node, node.modifiers); + writeKeyword("constructor"); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitAccessorDeclaration(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword(node.kind === 163 ? "get" : "set"); + writeSpace(); + emit(node.name); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitCallSignature(node) { + pushNameGenerationScope(node); + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitConstructSignature(node) { + pushNameGenerationScope(node); + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword("new"); + writeSpace(); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitIndexSignature(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emitParametersForIndexSignature(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + } + function emitSemicolonClassElement() { + writeTrailingSemicolon(); + } + function emitTypePredicate(node) { + if (node.assertsModifier) { + emit(node.assertsModifier); + writeSpace(); + } + emit(node.parameterName); + if (node.type) { + writeSpace(); + writeKeyword("is"); + writeSpace(); + emit(node.type); + } + } + function emitTypeReference(node) { + emit(node.typeName); + emitTypeArguments(node, node.typeArguments); + } + function emitFunctionType(node) { + pushNameGenerationScope(node); + emitTypeParameters(node, node.typeParameters); + emitParametersForArrow(node, node.parameters); + writeSpace(); + writePunctuation("=>"); + writeSpace(); + emit(node.type); + popNameGenerationScope(node); + } + function emitJSDocFunctionType(node) { + writeKeyword("function"); + emitParameters(node, node.parameters); + writePunctuation(":"); + emit(node.type); + } + function emitJSDocNullableType(node) { + writePunctuation("?"); + emit(node.type); + } + function emitJSDocNonNullableType(node) { + writePunctuation("!"); + emit(node.type); + } + function emitJSDocOptionalType(node) { + emit(node.type); + writePunctuation("="); + } + function emitConstructorType(node) { + pushNameGenerationScope(node); + writeKeyword("new"); + writeSpace(); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + writeSpace(); + writePunctuation("=>"); + writeSpace(); + emit(node.type); + popNameGenerationScope(node); + } + function emitTypeQuery(node) { + writeKeyword("typeof"); + writeSpace(); + emit(node.exprName); + } + function emitTypeLiteral(node) { + writePunctuation("{"); + var flags = ts.getEmitFlags(node) & 1 ? 768 : 32897; + emitList(node, node.members, flags | 524288); + writePunctuation("}"); + } + function emitArrayType(node) { + emit(node.elementType); + writePunctuation("["); + writePunctuation("]"); + } + function emitRestOrJSDocVariadicType(node) { + writePunctuation("..."); + emit(node.type); + } + function emitTupleType(node) { + writePunctuation("["); + emitList(node, node.elementTypes, 528); + writePunctuation("]"); + } + function emitOptionalType(node) { + emit(node.type); + writePunctuation("?"); + } + function emitUnionType(node) { + emitList(node, node.types, 516); + } + function emitIntersectionType(node) { + emitList(node, node.types, 520); + } + function emitConditionalType(node) { + emit(node.checkType); + writeSpace(); + writeKeyword("extends"); + writeSpace(); + emit(node.extendsType); + writeSpace(); + writePunctuation("?"); + writeSpace(); + emit(node.trueType); + writeSpace(); + writePunctuation(":"); + writeSpace(); + emit(node.falseType); + } + function emitInferType(node) { + writeKeyword("infer"); + writeSpace(); + emit(node.typeParameter); + } + function emitParenthesizedType(node) { + writePunctuation("("); + emit(node.type); + writePunctuation(")"); + } + function emitThisType() { + writeKeyword("this"); + } + function emitTypeOperator(node) { + writeTokenText(node.operator, writeKeyword); + writeSpace(); + emit(node.type); + } + function emitIndexedAccessType(node) { + emit(node.objectType); + writePunctuation("["); + emit(node.indexType); + writePunctuation("]"); + } + function emitMappedType(node) { + var emitFlags = ts.getEmitFlags(node); + writePunctuation("{"); + if (emitFlags & 1) { + writeSpace(); + } + else { + writeLine(); + increaseIndent(); + } + if (node.readonlyToken) { + emit(node.readonlyToken); + if (node.readonlyToken.kind !== 138) { + writeKeyword("readonly"); + } + writeSpace(); + } + writePunctuation("["); + pipelineEmit(3, node.typeParameter); + writePunctuation("]"); + if (node.questionToken) { + emit(node.questionToken); + if (node.questionToken.kind !== 57) { + writePunctuation("?"); + } + } + writePunctuation(":"); + writeSpace(); + emit(node.type); + writeTrailingSemicolon(); + if (emitFlags & 1) { + writeSpace(); + } + else { + writeLine(); + decreaseIndent(); + } + writePunctuation("}"); + } + function emitLiteralType(node) { + emitExpression(node.literal); + } + function emitImportTypeNode(node) { + if (node.isTypeOf) { + writeKeyword("typeof"); + writeSpace(); + } + writeKeyword("import"); + writePunctuation("("); + emit(node.argument); + writePunctuation(")"); + if (node.qualifier) { + writePunctuation("."); + emit(node.qualifier); + } + emitTypeArguments(node, node.typeArguments); + } + function emitObjectBindingPattern(node) { + writePunctuation("{"); + emitList(node, node.elements, 525136); + writePunctuation("}"); + } + function emitArrayBindingPattern(node) { + writePunctuation("["); + emitList(node, node.elements, 524880); + writePunctuation("]"); + } + function emitBindingElement(node) { + emit(node.dotDotDotToken); + if (node.propertyName) { + emit(node.propertyName); + writePunctuation(":"); + writeSpace(); + } + emit(node.name); + emitInitializer(node.initializer, node.name.end, node); + } + function emitArrayLiteralExpression(node) { + var elements = node.elements; + var preferNewLine = node.multiLine ? 65536 : 0; + emitExpressionList(node, elements, 8914 | preferNewLine); + } + function emitObjectLiteralExpression(node) { + ts.forEach(node.properties, generateMemberNames); + var indentedFlag = ts.getEmitFlags(node) & 65536; + if (indentedFlag) { + increaseIndent(); + } + var preferNewLine = node.multiLine ? 65536 : 0; + var allowTrailingComma = currentSourceFile.languageVersion >= 1 && !ts.isJsonSourceFile(currentSourceFile) ? 64 : 0; + emitList(node, node.properties, 526226 | allowTrailingComma | preferNewLine); + if (indentedFlag) { + decreaseIndent(); + } + } + function emitPropertyAccessExpression(node) { + var expression = ts.cast(emitExpression(node.expression), ts.isExpression); + var token = ts.getDotOrQuestionDotToken(node); + var indentBeforeDot = needsIndentation(node, node.expression, token); + var indentAfterDot = needsIndentation(node, token, node.name); + increaseIndentIf(indentBeforeDot, false); + var shouldEmitDotDot = token.kind !== 28 && + mayNeedDotDotForPropertyAccess(expression) && + !writer.hasTrailingComment() && + !writer.hasTrailingWhitespace(); + if (shouldEmitDotDot) { + writePunctuation("."); + } + emitTokenWithComment(token.kind, node.expression.end, writePunctuation, node); + increaseIndentIf(indentAfterDot, false); + emit(node.name); + decreaseIndentIf(indentBeforeDot, indentAfterDot); + } + function mayNeedDotDotForPropertyAccess(expression) { + expression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isNumericLiteral(expression)) { + var text = getLiteralTextOfNode(expression, true, false); + return !expression.numericLiteralFlags && !ts.stringContains(text, ts.tokenToString(24)); + } + else if (ts.isAccessExpression(expression)) { + var constantValue = ts.getConstantValue(expression); + return typeof constantValue === "number" && isFinite(constantValue) + && Math.floor(constantValue) === constantValue; + } + } + function emitElementAccessExpression(node) { + emitExpression(node.expression); + emit(node.questionDotToken); + emitTokenWithComment(22, node.expression.end, writePunctuation, node); + emitExpression(node.argumentExpression); + emitTokenWithComment(23, node.argumentExpression.end, writePunctuation, node); + } + function emitCallExpression(node) { + emitExpression(node.expression); + emit(node.questionDotToken); + emitTypeArguments(node, node.typeArguments); + emitExpressionList(node, node.arguments, 2576); + } + function emitNewExpression(node) { + emitTokenWithComment(99, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitTypeArguments(node, node.typeArguments); + emitExpressionList(node, node.arguments, 18960); + } + function emitTaggedTemplateExpression(node) { + emitExpression(node.tag); + emitTypeArguments(node, node.typeArguments); + writeSpace(); + emitExpression(node.template); + } + function emitTypeAssertionExpression(node) { + writePunctuation("<"); + emit(node.type); + writePunctuation(">"); + emitExpression(node.expression); + } + function emitParenthesizedExpression(node) { + var openParenPos = emitTokenWithComment(20, node.pos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression ? node.expression.end : openParenPos, writePunctuation, node); + } + function emitFunctionExpression(node) { + generateNameIfNeeded(node.name); + emitFunctionDeclarationOrExpression(node); + } + function emitArrowFunction(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + emitSignatureAndBody(node, emitArrowFunctionHead); + } + function emitArrowFunctionHead(node) { + emitTypeParameters(node, node.typeParameters); + emitParametersForArrow(node, node.parameters); + emitTypeAnnotation(node.type); + writeSpace(); + emit(node.equalsGreaterThanToken); + } + function emitDeleteExpression(node) { + emitTokenWithComment(85, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + } + function emitTypeOfExpression(node) { + emitTokenWithComment(108, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + } + function emitVoidExpression(node) { + emitTokenWithComment(110, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + } + function emitAwaitExpression(node) { + emitTokenWithComment(127, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + } + function emitPrefixUnaryExpression(node) { + writeTokenText(node.operator, writeOperator); + if (shouldEmitWhitespaceBeforeOperand(node)) { + writeSpace(); + } + emitExpression(node.operand); + } + function shouldEmitWhitespaceBeforeOperand(node) { + var operand = node.operand; + return operand.kind === 207 + && ((node.operator === 39 && (operand.operator === 39 || operand.operator === 45)) + || (node.operator === 40 && (operand.operator === 40 || operand.operator === 46))); + } + function emitPostfixUnaryExpression(node) { + emitExpression(node.operand); + writeTokenText(node.operator, writeOperator); + } + function emitBinaryExpression(node) { + var nodeStack = [node]; + var stateStack = [0]; + var stackIndex = 0; + while (stackIndex >= 0) { + node = nodeStack[stackIndex]; + switch (stateStack[stackIndex]) { + case 0: { + maybePipelineEmitExpression(node.left); + break; + } + case 1: { + var isCommaOperator = node.operatorToken.kind !== 27; + var indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken); + var indentAfterOperator = needsIndentation(node, node.operatorToken, node.right); + increaseIndentIf(indentBeforeOperator, isCommaOperator); + emitLeadingCommentsOfPosition(node.operatorToken.pos); + writeTokenNode(node.operatorToken, node.operatorToken.kind === 97 ? writeKeyword : writeOperator); + emitTrailingCommentsOfPosition(node.operatorToken.end, true); + increaseIndentIf(indentAfterOperator, true); + maybePipelineEmitExpression(node.right); + break; + } + case 2: { + var indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken); + var indentAfterOperator = needsIndentation(node, node.operatorToken, node.right); + decreaseIndentIf(indentBeforeOperator, indentAfterOperator); + stackIndex--; + break; + } + default: return ts.Debug.fail("Invalid state " + stateStack[stackIndex] + " for emitBinaryExpressionWorker"); + } + } + function maybePipelineEmitExpression(next) { + stateStack[stackIndex]++; + var savedLastNode = lastNode; + var savedLastSubstitution = lastSubstitution; + lastNode = next; + lastSubstitution = undefined; + var pipelinePhase = getPipelinePhase(0, 1, next); + if (pipelinePhase === pipelineEmitWithHint && ts.isBinaryExpression(next)) { + stackIndex++; + stateStack[stackIndex] = 0; + nodeStack[stackIndex] = next; + } + else { + pipelinePhase(1, next); + } + ts.Debug.assert(lastNode === next); + lastNode = savedLastNode; + lastSubstitution = savedLastSubstitution; + } + } + function emitConditionalExpression(node) { + var indentBeforeQuestion = needsIndentation(node, node.condition, node.questionToken); + var indentAfterQuestion = needsIndentation(node, node.questionToken, node.whenTrue); + var indentBeforeColon = needsIndentation(node, node.whenTrue, node.colonToken); + var indentAfterColon = needsIndentation(node, node.colonToken, node.whenFalse); + emitExpression(node.condition); + increaseIndentIf(indentBeforeQuestion, true); + emit(node.questionToken); + increaseIndentIf(indentAfterQuestion, true); + emitExpression(node.whenTrue); + decreaseIndentIf(indentBeforeQuestion, indentAfterQuestion); + increaseIndentIf(indentBeforeColon, true); + emit(node.colonToken); + increaseIndentIf(indentAfterColon, true); + emitExpression(node.whenFalse); + decreaseIndentIf(indentBeforeColon, indentAfterColon); + } + function emitTemplateExpression(node) { + emit(node.head); + emitList(node, node.templateSpans, 262144); + } + function emitYieldExpression(node) { + emitTokenWithComment(121, node.pos, writeKeyword, node); + emit(node.asteriskToken); + emitExpressionWithLeadingSpace(node.expression); + } + function emitSpreadExpression(node) { + emitTokenWithComment(25, node.pos, writePunctuation, node); + emitExpression(node.expression); + } + function emitClassExpression(node) { + generateNameIfNeeded(node.name); + emitClassDeclarationOrExpression(node); + } + function emitExpressionWithTypeArguments(node) { + emitExpression(node.expression); + emitTypeArguments(node, node.typeArguments); + } + function emitAsExpression(node) { + emitExpression(node.expression); + if (node.type) { + writeSpace(); + writeKeyword("as"); + writeSpace(); + emit(node.type); + } + } + function emitNonNullExpression(node) { + emitExpression(node.expression); + writeOperator("!"); + } + function emitMetaProperty(node) { + writeToken(node.keywordToken, node.pos, writePunctuation); + writePunctuation("."); + emit(node.name); + } + function emitTemplateSpan(node) { + emitExpression(node.expression); + emit(node.literal); + } + function emitBlock(node) { + emitBlockStatements(node, !node.multiLine && isEmptyBlock(node)); + } + function emitBlockStatements(node, forceSingleLine) { + emitTokenWithComment(18, node.pos, writePunctuation, node); + var format = forceSingleLine || ts.getEmitFlags(node) & 1 ? 768 : 129; + emitList(node, node.statements, format); + emitTokenWithComment(19, node.statements.end, writePunctuation, node, !!(format & 1)); + } + function emitVariableStatement(node) { + emitModifiers(node, node.modifiers); + emit(node.declarationList); + writeTrailingSemicolon(); + } + function emitEmptyStatement(isEmbeddedStatement) { + if (isEmbeddedStatement) { + writePunctuation(";"); + } + else { + writeTrailingSemicolon(); + } + } + function emitExpressionStatement(node) { + emitExpression(node.expression); + if (!ts.isJsonSourceFile(currentSourceFile) || ts.nodeIsSynthesized(node.expression)) { + writeTrailingSemicolon(); + } + } + function emitIfStatement(node) { + var openParenPos = emitTokenWithComment(95, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.thenStatement); + if (node.elseStatement) { + writeLineOrSpace(node); + emitTokenWithComment(87, node.thenStatement.end, writeKeyword, node); + if (node.elseStatement.kind === 227) { + writeSpace(); + emit(node.elseStatement); + } + else { + emitEmbeddedStatement(node, node.elseStatement); + } + } + } + function emitWhileClause(node, startPos) { + var openParenPos = emitTokenWithComment(111, startPos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + } + function emitDoStatement(node) { + emitTokenWithComment(86, node.pos, writeKeyword, node); + emitEmbeddedStatement(node, node.statement); + if (ts.isBlock(node.statement)) { + writeSpace(); + } + else { + writeLineOrSpace(node); + } + emitWhileClause(node, node.statement.end); + writeTrailingSemicolon(); + } + function emitWhileStatement(node) { + emitWhileClause(node, node.pos); + emitEmbeddedStatement(node, node.statement); + } + function emitForStatement(node) { + var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node); + writeSpace(); + var pos = emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitForBinding(node.initializer); + pos = emitTokenWithComment(26, node.initializer ? node.initializer.end : pos, writePunctuation, node); + emitExpressionWithLeadingSpace(node.condition); + pos = emitTokenWithComment(26, node.condition ? node.condition.end : pos, writePunctuation, node); + emitExpressionWithLeadingSpace(node.incrementor); + emitTokenWithComment(21, node.incrementor ? node.incrementor.end : pos, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForInStatement(node) { + var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitForBinding(node.initializer); + writeSpace(); + emitTokenWithComment(97, node.initializer.end, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForOfStatement(node) { + var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node); + writeSpace(); + emitWithTrailingSpace(node.awaitModifier); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitForBinding(node.initializer); + writeSpace(); + emitTokenWithComment(152, node.initializer.end, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForBinding(node) { + if (node !== undefined) { + if (node.kind === 243) { + emit(node); + } + else { + emitExpression(node); + } + } + } + function emitContinueStatement(node) { + emitTokenWithComment(82, node.pos, writeKeyword, node); + emitWithLeadingSpace(node.label); + writeTrailingSemicolon(); + } + function emitBreakStatement(node) { + emitTokenWithComment(77, node.pos, writeKeyword, node); + emitWithLeadingSpace(node.label); + writeTrailingSemicolon(); + } + function emitTokenWithComment(token, pos, writer, contextNode, indentLeading) { + var node = ts.getParseTreeNode(contextNode); + var isSimilarNode = node && node.kind === contextNode.kind; + var startPos = pos; + if (isSimilarNode && currentSourceFile) { + pos = ts.skipTrivia(currentSourceFile.text, pos); + } + if (emitLeadingCommentsOfPosition && isSimilarNode && contextNode.pos !== startPos) { + var needsIndent = indentLeading && currentSourceFile && !ts.positionsAreOnSameLine(startPos, pos, currentSourceFile); + if (needsIndent) { + increaseIndent(); + } + emitLeadingCommentsOfPosition(startPos); + if (needsIndent) { + decreaseIndent(); + } + } + pos = writeTokenText(token, writer, pos); + if (emitTrailingCommentsOfPosition && isSimilarNode && contextNode.end !== pos) { + emitTrailingCommentsOfPosition(pos, true); + } + return pos; + } + function emitReturnStatement(node) { + emitTokenWithComment(101, node.pos, writeKeyword, node); + emitExpressionWithLeadingSpace(node.expression); + writeTrailingSemicolon(); + } + function emitWithStatement(node) { + var openParenPos = emitTokenWithComment(112, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitSwitchStatement(node) { + var openParenPos = emitTokenWithComment(103, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21, node.expression.end, writePunctuation, node); + writeSpace(); + emit(node.caseBlock); + } + function emitLabeledStatement(node) { + emit(node.label); + emitTokenWithComment(58, node.label.end, writePunctuation, node); + writeSpace(); + emit(node.statement); + } + function emitThrowStatement(node) { + emitTokenWithComment(105, node.pos, writeKeyword, node); + emitExpressionWithLeadingSpace(node.expression); + writeTrailingSemicolon(); + } + function emitTryStatement(node) { + emitTokenWithComment(107, node.pos, writeKeyword, node); + writeSpace(); + emit(node.tryBlock); + if (node.catchClause) { + writeLineOrSpace(node); + emit(node.catchClause); + } + if (node.finallyBlock) { + writeLineOrSpace(node); + emitTokenWithComment(92, (node.catchClause || node.tryBlock).end, writeKeyword, node); + writeSpace(); + emit(node.finallyBlock); + } + } + function emitDebuggerStatement(node) { + writeToken(83, node.pos, writeKeyword); + writeTrailingSemicolon(); + } + function emitVariableDeclaration(node) { + emit(node.name); + emit(node.exclamationToken); + emitTypeAnnotation(node.type); + emitInitializer(node.initializer, node.type ? node.type.end : node.name.end, node); + } + function emitVariableDeclarationList(node) { + writeKeyword(ts.isLet(node) ? "let" : ts.isVarConst(node) ? "const" : "var"); + writeSpace(); + emitList(node, node.declarations, 528); + } + function emitFunctionDeclaration(node) { + emitFunctionDeclarationOrExpression(node); + } + function emitFunctionDeclarationOrExpression(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword("function"); + emit(node.asteriskToken); + writeSpace(); + emitIdentifierName(node.name); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitBlockCallback(_hint, body) { + emitBlockFunctionBody(body); + } + function emitSignatureAndBody(node, emitSignatureHead) { + var body = node.body; + if (body) { + if (ts.isBlock(body)) { + var indentedFlag = ts.getEmitFlags(node) & 65536; + if (indentedFlag) { + increaseIndent(); + } + pushNameGenerationScope(node); + ts.forEach(node.parameters, generateNames); + generateNames(node.body); + emitSignatureHead(node); + if (onEmitNode) { + onEmitNode(4, body, emitBlockCallback); + } + else { + emitBlockFunctionBody(body); + } + popNameGenerationScope(node); + if (indentedFlag) { + decreaseIndent(); + } + } + else { + emitSignatureHead(node); + writeSpace(); + emitExpression(body); + } + } + else { + emitSignatureHead(node); + writeTrailingSemicolon(); + } + } + function emitSignatureHead(node) { + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + } + function shouldEmitBlockFunctionBodyOnSingleLine(body) { + if (ts.getEmitFlags(body) & 1) { + return true; + } + if (body.multiLine) { + return false; + } + if (!ts.nodeIsSynthesized(body) && !ts.rangeIsOnSingleLine(body, currentSourceFile)) { + return false; + } + if (shouldWriteLeadingLineTerminator(body, body.statements, 2) + || shouldWriteClosingLineTerminator(body, body.statements, 2)) { + return false; + } + var previousStatement; + for (var _a = 0, _b = body.statements; _a < _b.length; _a++) { + var statement = _b[_a]; + if (shouldWriteSeparatingLineTerminator(previousStatement, statement, 2)) { + return false; + } + previousStatement = statement; + } + return true; + } + function emitBlockFunctionBody(body) { + writeSpace(); + writePunctuation("{"); + increaseIndent(); + var emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body) + ? emitBlockFunctionBodyOnSingleLine + : emitBlockFunctionBodyWorker; + if (emitBodyWithDetachedComments) { + emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody); + } + else { + emitBlockFunctionBody(body); + } + decreaseIndent(); + writeToken(19, body.statements.end, writePunctuation, body); + } + function emitBlockFunctionBodyOnSingleLine(body) { + emitBlockFunctionBodyWorker(body, true); + } + function emitBlockFunctionBodyWorker(body, emitBlockFunctionBodyOnSingleLine) { + var statementOffset = emitPrologueDirectives(body.statements); + var pos = writer.getTextPos(); + emitHelpers(body); + if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) { + decreaseIndent(); + emitList(body, body.statements, 768); + increaseIndent(); + } + else { + emitList(body, body.statements, 1, statementOffset); + } + } + function emitClassDeclaration(node) { + emitClassDeclarationOrExpression(node); + } + function emitClassDeclarationOrExpression(node) { + ts.forEach(node.members, generateMemberNames); + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword("class"); + if (node.name) { + writeSpace(); + emitIdentifierName(node.name); + } + var indentedFlag = ts.getEmitFlags(node) & 65536; + if (indentedFlag) { + increaseIndent(); + } + emitTypeParameters(node, node.typeParameters); + emitList(node, node.heritageClauses, 0); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 129); + writePunctuation("}"); + if (indentedFlag) { + decreaseIndent(); + } + } + function emitInterfaceDeclaration(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword("interface"); + writeSpace(); + emit(node.name); + emitTypeParameters(node, node.typeParameters); + emitList(node, node.heritageClauses, 512); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 129); + writePunctuation("}"); + } + function emitTypeAliasDeclaration(node) { + emitDecorators(node, node.decorators); + emitModifiers(node, node.modifiers); + writeKeyword("type"); + writeSpace(); + emit(node.name); + emitTypeParameters(node, node.typeParameters); + writeSpace(); + writePunctuation("="); + writeSpace(); + emit(node.type); + writeTrailingSemicolon(); + } + function emitEnumDeclaration(node) { + emitModifiers(node, node.modifiers); + writeKeyword("enum"); + writeSpace(); + emit(node.name); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 145); + writePunctuation("}"); + } + function emitModuleDeclaration(node) { + emitModifiers(node, node.modifiers); + if (~node.flags & 1024) { + writeKeyword(node.flags & 16 ? "namespace" : "module"); + writeSpace(); + } + emit(node.name); + var body = node.body; + if (!body) + return writeTrailingSemicolon(); + while (body.kind === 249) { + writePunctuation("."); + emit(body.name); + body = body.body; + } + writeSpace(); + emit(body); + } + function emitModuleBlock(node) { + pushNameGenerationScope(node); + ts.forEach(node.statements, generateNames); + emitBlockStatements(node, isEmptyBlock(node)); + popNameGenerationScope(node); + } + function emitCaseBlock(node) { + emitTokenWithComment(18, node.pos, writePunctuation, node); + emitList(node, node.clauses, 129); + emitTokenWithComment(19, node.clauses.end, writePunctuation, node, true); + } + function emitImportEqualsDeclaration(node) { + emitModifiers(node, node.modifiers); + emitTokenWithComment(96, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node); + writeSpace(); + emit(node.name); + writeSpace(); + emitTokenWithComment(62, node.name.end, writePunctuation, node); + writeSpace(); + emitModuleReference(node.moduleReference); + writeTrailingSemicolon(); + } + function emitModuleReference(node) { + if (node.kind === 75) { + emitExpression(node); + } + else { + emit(node); + } + } + function emitImportDeclaration(node) { + emitModifiers(node, node.modifiers); + emitTokenWithComment(96, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node); + writeSpace(); + if (node.importClause) { + emit(node.importClause); + writeSpace(); + emitTokenWithComment(149, node.importClause.end, writeKeyword, node); + writeSpace(); + } + emitExpression(node.moduleSpecifier); + writeTrailingSemicolon(); + } + function emitImportClause(node) { + if (node.isTypeOnly) { + emitTokenWithComment(145, node.pos, writeKeyword, node); + writeSpace(); + } + emit(node.name); + if (node.name && node.namedBindings) { + emitTokenWithComment(27, node.name.end, writePunctuation, node); + writeSpace(); + } + emit(node.namedBindings); + } + function emitNamespaceImport(node) { + var asPos = emitTokenWithComment(41, node.pos, writePunctuation, node); + writeSpace(); + emitTokenWithComment(123, asPos, writeKeyword, node); + writeSpace(); + emit(node.name); + } + function emitNamedImports(node) { + emitNamedImportsOrExports(node); + } + function emitImportSpecifier(node) { + emitImportOrExportSpecifier(node); + } + function emitExportAssignment(node) { + var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node); + writeSpace(); + if (node.isExportEquals) { + emitTokenWithComment(62, nextPos, writeOperator, node); + } + else { + emitTokenWithComment(84, nextPos, writeKeyword, node); + } + writeSpace(); + emitExpression(node.expression); + writeTrailingSemicolon(); + } + function emitExportDeclaration(node) { + var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node); + writeSpace(); + if (node.isTypeOnly) { + nextPos = emitTokenWithComment(145, nextPos, writeKeyword, node); + writeSpace(); + } + if (node.exportClause) { + emit(node.exportClause); + } + else { + nextPos = emitTokenWithComment(41, nextPos, writePunctuation, node); + } + if (node.moduleSpecifier) { + writeSpace(); + var fromPos = node.exportClause ? node.exportClause.end : nextPos; + emitTokenWithComment(149, fromPos, writeKeyword, node); + writeSpace(); + emitExpression(node.moduleSpecifier); + } + writeTrailingSemicolon(); + } + function emitNamespaceExportDeclaration(node) { + var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node); + writeSpace(); + nextPos = emitTokenWithComment(123, nextPos, writeKeyword, node); + writeSpace(); + nextPos = emitTokenWithComment(136, nextPos, writeKeyword, node); + writeSpace(); + emit(node.name); + writeTrailingSemicolon(); + } + function emitNamespaceExport(node) { + var asPos = emitTokenWithComment(41, node.pos, writePunctuation, node); + writeSpace(); + emitTokenWithComment(123, asPos, writeKeyword, node); + writeSpace(); + emit(node.name); + } + function emitNamedExports(node) { + emitNamedImportsOrExports(node); + } + function emitExportSpecifier(node) { + emitImportOrExportSpecifier(node); + } + function emitNamedImportsOrExports(node) { + writePunctuation("{"); + emitList(node, node.elements, 525136); + writePunctuation("}"); + } + function emitImportOrExportSpecifier(node) { + if (node.propertyName) { + emit(node.propertyName); + writeSpace(); + emitTokenWithComment(123, node.propertyName.end, writeKeyword, node); + writeSpace(); + } + emit(node.name); + } + function emitExternalModuleReference(node) { + writeKeyword("require"); + writePunctuation("("); + emitExpression(node.expression); + writePunctuation(")"); + } + function emitJsxElement(node) { + emit(node.openingElement); + emitList(node, node.children, 262144); + emit(node.closingElement); + } + function emitJsxSelfClosingElement(node) { + writePunctuation("<"); + emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); + writeSpace(); + emit(node.attributes); + writePunctuation("/>"); + } + function emitJsxFragment(node) { + emit(node.openingFragment); + emitList(node, node.children, 262144); + emit(node.closingFragment); + } + function emitJsxOpeningElementOrFragment(node) { + writePunctuation("<"); + if (ts.isJsxOpeningElement(node)) { + emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); + if (node.attributes.properties && node.attributes.properties.length > 0) { + writeSpace(); + } + emit(node.attributes); + } + writePunctuation(">"); + } + function emitJsxText(node) { + writer.writeLiteral(node.text); + } + function emitJsxClosingElementOrFragment(node) { + writePunctuation(""); + } + function emitJsxAttributes(node) { + emitList(node, node.properties, 262656); + } + function emitJsxAttribute(node) { + emit(node.name); + emitNodeWithPrefix("=", writePunctuation, node.initializer, emitJsxAttributeValue); + } + function emitJsxSpreadAttribute(node) { + writePunctuation("{..."); + emitExpression(node.expression); + writePunctuation("}"); + } + function emitJsxExpression(node) { + if (node.expression) { + writePunctuation("{"); + emit(node.dotDotDotToken); + emitExpression(node.expression); + writePunctuation("}"); + } + } + function emitJsxTagName(node) { + if (node.kind === 75) { + emitExpression(node); + } + else { + emit(node); + } + } + function emitCaseClause(node) { + emitTokenWithComment(78, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end); + } + function emitDefaultClause(node) { + var pos = emitTokenWithComment(84, node.pos, writeKeyword, node); + emitCaseOrDefaultClauseRest(node, node.statements, pos); + } + function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) { + var emitAsSingleStatement = statements.length === 1 && + (ts.nodeIsSynthesized(parentNode) || + ts.nodeIsSynthesized(statements[0]) || + ts.rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)); + var format = 163969; + if (emitAsSingleStatement) { + writeToken(58, colonPos, writePunctuation, parentNode); + writeSpace(); + format &= ~(1 | 128); + } + else { + emitTokenWithComment(58, colonPos, writePunctuation, parentNode); + } + emitList(parentNode, statements, format); + } + function emitHeritageClause(node) { + writeSpace(); + writeTokenText(node.token, writeKeyword); + writeSpace(); + emitList(node, node.types, 528); + } + function emitCatchClause(node) { + var openParenPos = emitTokenWithComment(79, node.pos, writeKeyword, node); + writeSpace(); + if (node.variableDeclaration) { + emitTokenWithComment(20, openParenPos, writePunctuation, node); + emit(node.variableDeclaration); + emitTokenWithComment(21, node.variableDeclaration.end, writePunctuation, node); + writeSpace(); + } + emit(node.block); + } + function emitPropertyAssignment(node) { + emit(node.name); + writePunctuation(":"); + writeSpace(); + var initializer = node.initializer; + if (emitTrailingCommentsOfPosition && (ts.getEmitFlags(initializer) & 512) === 0) { + var commentRange = ts.getCommentRange(initializer); + emitTrailingCommentsOfPosition(commentRange.pos); + } + emitExpression(initializer); + } + function emitShorthandPropertyAssignment(node) { + emit(node.name); + if (node.objectAssignmentInitializer) { + writeSpace(); + writePunctuation("="); + writeSpace(); + emitExpression(node.objectAssignmentInitializer); + } + } + function emitSpreadAssignment(node) { + if (node.expression) { + emitTokenWithComment(25, node.pos, writePunctuation, node); + emitExpression(node.expression); + } + } + function emitEnumMember(node) { + emit(node.name); + emitInitializer(node.initializer, node.name.end, node); + } + function emitJSDoc(node) { + write("/**"); + if (node.comment) { + var lines = node.comment.split(/\r\n?|\n/g); + for (var _a = 0, lines_2 = lines; _a < lines_2.length; _a++) { + var line = lines_2[_a]; + writeLine(); + writeSpace(); + writePunctuation("*"); + writeSpace(); + write(line); + } + } + if (node.tags) { + if (node.tags.length === 1 && node.tags[0].kind === 319 && !node.comment) { + writeSpace(); + emit(node.tags[0]); + } + else { + emitList(node, node.tags, 33); + } + } + writeSpace(); + write("*/"); + } + function emitJSDocSimpleTypedTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocTypeExpression(tag.typeExpression); + emitJSDocComment(tag.comment); + } + function emitJSDocAugmentsTag(tag) { + emitJSDocTagName(tag.tagName); + writeSpace(); + writePunctuation("{"); + emit(tag.class); + writePunctuation("}"); + emitJSDocComment(tag.comment); + } + function emitJSDocTemplateTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocTypeExpression(tag.constraint); + writeSpace(); + emitList(tag, tag.typeParameters, 528); + emitJSDocComment(tag.comment); + } + function emitJSDocTypedefTag(tag) { + emitJSDocTagName(tag.tagName); + if (tag.typeExpression) { + if (tag.typeExpression.kind === 294) { + emitJSDocTypeExpression(tag.typeExpression); + } + else { + writeSpace(); + writePunctuation("{"); + write("Object"); + if (tag.typeExpression.isArrayType) { + writePunctuation("["); + writePunctuation("]"); + } + writePunctuation("}"); + } + } + if (tag.fullName) { + writeSpace(); + emit(tag.fullName); + } + emitJSDocComment(tag.comment); + if (tag.typeExpression && tag.typeExpression.kind === 304) { + emitJSDocTypeLiteral(tag.typeExpression); + } + } + function emitJSDocCallbackTag(tag) { + emitJSDocTagName(tag.tagName); + if (tag.name) { + writeSpace(); + emit(tag.name); + } + emitJSDocComment(tag.comment); + emitJSDocSignature(tag.typeExpression); + } + function emitJSDocSimpleTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocComment(tag.comment); + } + function emitJSDocTypeLiteral(lit) { + emitList(lit, ts.createNodeArray(lit.jsDocPropertyTags), 33); + } + function emitJSDocSignature(sig) { + if (sig.typeParameters) { + emitList(sig, ts.createNodeArray(sig.typeParameters), 33); + } + if (sig.parameters) { + emitList(sig, ts.createNodeArray(sig.parameters), 33); + } + if (sig.type) { + writeLine(); + writeSpace(); + writePunctuation("*"); + writeSpace(); + emit(sig.type); + } + } + function emitJSDocPropertyLikeTag(param) { + emitJSDocTagName(param.tagName); + emitJSDocTypeExpression(param.typeExpression); + writeSpace(); + if (param.isBracketed) { + writePunctuation("["); + } + emit(param.name); + if (param.isBracketed) { + writePunctuation("]"); + } + emitJSDocComment(param.comment); + } + function emitJSDocTagName(tagName) { + writePunctuation("@"); + emit(tagName); + } + function emitJSDocComment(comment) { + if (comment) { + writeSpace(); + write(comment); + } + } + function emitJSDocTypeExpression(typeExpression) { + if (typeExpression) { + writeSpace(); + writePunctuation("{"); + emit(typeExpression.type); + writePunctuation("}"); + } + } + function emitSourceFile(node) { + writeLine(); + var statements = node.statements; + if (emitBodyWithDetachedComments) { + var shouldEmitDetachedComment = statements.length === 0 || + !ts.isPrologueDirective(statements[0]) || + ts.nodeIsSynthesized(statements[0]); + if (shouldEmitDetachedComment) { + emitBodyWithDetachedComments(node, statements, emitSourceFileWorker); + return; + } + } + emitSourceFileWorker(node); + } + function emitSyntheticTripleSlashReferencesIfNeeded(node) { + emitTripleSlashDirectives(!!node.hasNoDefaultLib, node.syntheticFileReferences || [], node.syntheticTypeReferences || [], node.syntheticLibReferences || []); + for (var _a = 0, _b = node.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + if (ts.isUnparsedSource(prepend) && prepend.syntheticReferences) { + for (var _c = 0, _d = prepend.syntheticReferences; _c < _d.length; _c++) { + var ref = _d[_c]; + emit(ref); + writeLine(); + } + } + } + } + function emitTripleSlashDirectivesIfNeeded(node) { + if (node.isDeclarationFile) + emitTripleSlashDirectives(node.hasNoDefaultLib, node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives); + } + function emitTripleSlashDirectives(hasNoDefaultLib, files, types, libs) { + if (hasNoDefaultLib) { + var pos = writer.getTextPos(); + writeComment("/// "); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "no-default-lib" }); + writeLine(); + } + if (currentSourceFile && currentSourceFile.moduleName) { + writeComment("/// "); + writeLine(); + } + if (currentSourceFile && currentSourceFile.amdDependencies) { + for (var _a = 0, _b = currentSourceFile.amdDependencies; _a < _b.length; _a++) { + var dep = _b[_a]; + if (dep.name) { + writeComment("/// "); + } + else { + writeComment("/// "); + } + writeLine(); + } + } + for (var _c = 0, files_1 = files; _c < files_1.length; _c++) { + var directive = files_1[_c]; + var pos = writer.getTextPos(); + writeComment("/// "); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference", data: directive.fileName }); + writeLine(); + } + for (var _d = 0, types_21 = types; _d < types_21.length; _d++) { + var directive = types_21[_d]; + var pos = writer.getTextPos(); + writeComment("/// "); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "type", data: directive.fileName }); + writeLine(); + } + for (var _e = 0, libs_1 = libs; _e < libs_1.length; _e++) { + var directive = libs_1[_e]; + var pos = writer.getTextPos(); + writeComment("/// "); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "lib", data: directive.fileName }); + writeLine(); + } + } + function emitSourceFileWorker(node) { + var statements = node.statements; + pushNameGenerationScope(node); + ts.forEach(node.statements, generateNames); + emitHelpers(node); + var index = ts.findIndex(statements, function (statement) { return !ts.isPrologueDirective(statement); }); + emitTripleSlashDirectivesIfNeeded(node); + emitList(node, statements, 1, index === -1 ? statements.length : index); + popNameGenerationScope(node); + } + function emitPartiallyEmittedExpression(node) { + emitExpression(node.expression); + } + function emitCommaList(node) { + emitExpressionList(node, node.elements, 528); + } + function emitPrologueDirectives(statements, sourceFile, seenPrologueDirectives, recordBundleFileSection) { + var needsToSetSourceFile = !!sourceFile; + for (var i = 0; i < statements.length; i++) { + var statement = statements[i]; + if (ts.isPrologueDirective(statement)) { + var shouldEmitPrologueDirective = seenPrologueDirectives ? !seenPrologueDirectives.has(statement.expression.text) : true; + if (shouldEmitPrologueDirective) { + if (needsToSetSourceFile) { + needsToSetSourceFile = false; + setSourceFile(sourceFile); + } + writeLine(); + var pos = writer.getTextPos(); + emit(statement); + if (recordBundleFileSection && bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue", data: statement.expression.text }); + if (seenPrologueDirectives) { + seenPrologueDirectives.set(statement.expression.text, true); + } + } + } + else { + return i; + } + } + return statements.length; + } + function emitUnparsedPrologues(prologues, seenPrologueDirectives) { + for (var _a = 0, prologues_1 = prologues; _a < prologues_1.length; _a++) { + var prologue = prologues_1[_a]; + if (!seenPrologueDirectives.has(prologue.data)) { + writeLine(); + var pos = writer.getTextPos(); + emit(prologue); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue", data: prologue.data }); + if (seenPrologueDirectives) { + seenPrologueDirectives.set(prologue.data, true); + } + } + } + } + function emitPrologueDirectivesIfNeeded(sourceFileOrBundle) { + if (ts.isSourceFile(sourceFileOrBundle)) { + emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle); + } + else { + var seenPrologueDirectives = ts.createMap(); + for (var _a = 0, _b = sourceFileOrBundle.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + emitUnparsedPrologues(prepend.prologues, seenPrologueDirectives); + } + for (var _c = 0, _d = sourceFileOrBundle.sourceFiles; _c < _d.length; _c++) { + var sourceFile = _d[_c]; + emitPrologueDirectives(sourceFile.statements, sourceFile, seenPrologueDirectives, true); + } + setSourceFile(undefined); + } + } + function getPrologueDirectivesFromBundledSourceFiles(bundle) { + var seenPrologueDirectives = ts.createMap(); + var prologues; + for (var index = 0; index < bundle.sourceFiles.length; index++) { + var sourceFile = bundle.sourceFiles[index]; + var directives = void 0; + var end = 0; + for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { + var statement = _b[_a]; + if (!ts.isPrologueDirective(statement)) + break; + if (seenPrologueDirectives.has(statement.expression.text)) + continue; + seenPrologueDirectives.set(statement.expression.text, true); + (directives || (directives = [])).push({ + pos: statement.pos, + end: statement.end, + expression: { + pos: statement.expression.pos, + end: statement.expression.end, + text: statement.expression.text + } + }); + end = end < statement.end ? statement.end : end; + } + if (directives) + (prologues || (prologues = [])).push({ file: index, text: sourceFile.text.substring(0, end), directives: directives }); + } + return prologues; + } + function emitShebangIfNeeded(sourceFileOrBundle) { + if (ts.isSourceFile(sourceFileOrBundle) || ts.isUnparsedSource(sourceFileOrBundle)) { + var shebang = ts.getShebang(sourceFileOrBundle.text); + if (shebang) { + writeComment(shebang); + writeLine(); + return true; + } + } + else { + for (var _a = 0, _b = sourceFileOrBundle.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + ts.Debug.assertNode(prepend, ts.isUnparsedSource); + if (emitShebangIfNeeded(prepend)) { + return true; + } + } + for (var _c = 0, _d = sourceFileOrBundle.sourceFiles; _c < _d.length; _c++) { + var sourceFile = _d[_c]; + if (emitShebangIfNeeded(sourceFile)) { + return true; + } + } + } + } + function emitNodeWithWriter(node, writer) { + if (!node) + return; + var savedWrite = write; + write = writer; + emit(node); + write = savedWrite; + } + function emitModifiers(node, modifiers) { + if (modifiers && modifiers.length) { + emitList(node, modifiers, 262656); + writeSpace(); + } + } + function emitTypeAnnotation(node) { + if (node) { + writePunctuation(":"); + writeSpace(); + emit(node); + } + } + function emitInitializer(node, equalCommentStartPos, container) { + if (node) { + writeSpace(); + emitTokenWithComment(62, equalCommentStartPos, writeOperator, container); + writeSpace(); + emitExpression(node); + } + } + function emitNodeWithPrefix(prefix, prefixWriter, node, emit) { + if (node) { + prefixWriter(prefix); + emit(node); + } + } + function emitWithLeadingSpace(node) { + if (node) { + writeSpace(); + emit(node); + } + } + function emitExpressionWithLeadingSpace(node) { + if (node) { + writeSpace(); + emitExpression(node); + } + } + function emitWithTrailingSpace(node) { + if (node) { + emit(node); + writeSpace(); + } + } + function emitEmbeddedStatement(parent, node) { + if (ts.isBlock(node) || ts.getEmitFlags(parent) & 1) { + writeSpace(); + emit(node); + } + else { + writeLine(); + increaseIndent(); + if (ts.isEmptyStatement(node)) { + pipelineEmit(5, node); + } + else { + emit(node); + } + decreaseIndent(); + } + } + function emitDecorators(parentNode, decorators) { + emitList(parentNode, decorators, 49153); + } + function emitTypeArguments(parentNode, typeArguments) { + emitList(parentNode, typeArguments, 53776); + } + function emitTypeParameters(parentNode, typeParameters) { + if (ts.isFunctionLike(parentNode) && parentNode.typeArguments) { + return emitTypeArguments(parentNode, parentNode.typeArguments); + } + emitList(parentNode, typeParameters, 53776); + } + function emitParameters(parentNode, parameters) { + emitList(parentNode, parameters, 2576); + } + function canEmitSimpleArrowHead(parentNode, parameters) { + var parameter = ts.singleOrUndefined(parameters); + return parameter + && parameter.pos === parentNode.pos + && ts.isArrowFunction(parentNode) + && !parentNode.type + && !ts.some(parentNode.decorators) + && !ts.some(parentNode.modifiers) + && !ts.some(parentNode.typeParameters) + && !ts.some(parameter.decorators) + && !ts.some(parameter.modifiers) + && !parameter.dotDotDotToken + && !parameter.questionToken + && !parameter.type + && !parameter.initializer + && ts.isIdentifier(parameter.name); + } + function emitParametersForArrow(parentNode, parameters) { + if (canEmitSimpleArrowHead(parentNode, parameters)) { + emitList(parentNode, parameters, 2576 & ~2048); + } + else { + emitParameters(parentNode, parameters); + } + } + function emitParametersForIndexSignature(parentNode, parameters) { + emitList(parentNode, parameters, 8848); + } + function emitList(parentNode, children, format, start, count) { + emitNodeList(emit, parentNode, children, format, start, count); + } + function emitExpressionList(parentNode, children, format, start, count) { + emitNodeList(emitExpression, parentNode, children, format, start, count); + } + function writeDelimiter(format) { + switch (format & 60) { + case 0: + break; + case 16: + writePunctuation(","); + break; + case 4: + writeSpace(); + writePunctuation("|"); + break; + case 32: + writeSpace(); + writePunctuation("*"); + writeSpace(); + break; + case 8: + writeSpace(); + writePunctuation("&"); + break; + } + } + function emitNodeList(emit, parentNode, children, format, start, count) { + if (start === void 0) { start = 0; } + if (count === void 0) { count = children ? children.length - start : 0; } + var isUndefined = children === undefined; + if (isUndefined && format & 16384) { + return; + } + var isEmpty = children === undefined || start >= children.length || count === 0; + if (isEmpty && format & 32768) { + if (onBeforeEmitNodeArray) { + onBeforeEmitNodeArray(children); + } + if (onAfterEmitNodeArray) { + onAfterEmitNodeArray(children); + } + return; + } + if (format & 15360) { + writePunctuation(getOpeningBracket(format)); + if (isEmpty && !isUndefined) { + emitTrailingCommentsOfPosition(children.pos, true); + } + } + if (onBeforeEmitNodeArray) { + onBeforeEmitNodeArray(children); + } + if (isEmpty) { + if (format & 1) { + writeLine(); + } + else if (format & 256 && !(format & 524288)) { + writeSpace(); + } + } + else { + var mayEmitInterveningComments = (format & 262144) === 0; + var shouldEmitInterveningComments = mayEmitInterveningComments; + if (shouldWriteLeadingLineTerminator(parentNode, children, format)) { + writeLine(); + shouldEmitInterveningComments = false; + } + else if (format & 256) { + writeSpace(); + } + if (format & 128) { + increaseIndent(); + } + var previousSibling = void 0; + var previousSourceFileTextKind = void 0; + var shouldDecreaseIndentAfterEmit = false; + for (var i = 0; i < count; i++) { + var child = children[start + i]; + if (format & 32) { + writeLine(); + writeDelimiter(format); + } + else if (previousSibling) { + if (format & 60 && previousSibling.end !== parentNode.end) { + emitLeadingCommentsOfPosition(previousSibling.end); + } + writeDelimiter(format); + recordBundleFileInternalSectionEnd(previousSourceFileTextKind); + if (shouldWriteSeparatingLineTerminator(previousSibling, child, format)) { + if ((format & (3 | 128)) === 0) { + increaseIndent(); + shouldDecreaseIndentAfterEmit = true; + } + writeLine(); + shouldEmitInterveningComments = false; + } + else if (previousSibling && format & 512) { + writeSpace(); + } + } + previousSourceFileTextKind = recordBundleFileInternalSectionStart(child); + if (shouldEmitInterveningComments) { + if (emitTrailingCommentsOfPosition) { + var commentRange = ts.getCommentRange(child); + emitTrailingCommentsOfPosition(commentRange.pos); + } + } + else { + shouldEmitInterveningComments = mayEmitInterveningComments; + } + emit(child); + if (shouldDecreaseIndentAfterEmit) { + decreaseIndent(); + shouldDecreaseIndentAfterEmit = false; + } + previousSibling = child; + } + var hasTrailingComma = (format & 64) && children.hasTrailingComma; + if (format & 16 && hasTrailingComma) { + writePunctuation(","); + } + if (previousSibling && format & 60 && previousSibling.end !== parentNode.end && !(ts.getEmitFlags(previousSibling) & 1024)) { + emitLeadingCommentsOfPosition(previousSibling.end); + } + if (format & 128) { + decreaseIndent(); + } + recordBundleFileInternalSectionEnd(previousSourceFileTextKind); + if (shouldWriteClosingLineTerminator(parentNode, children, format)) { + writeLine(); + } + else if (format & 256) { + writeSpace(); + } + } + if (onAfterEmitNodeArray) { + onAfterEmitNodeArray(children); + } + if (format & 15360) { + if (isEmpty && !isUndefined) { + emitLeadingCommentsOfPosition(children.end); + } + writePunctuation(getClosingBracket(format)); + } + } + function writeLiteral(s) { + writer.writeLiteral(s); + } + function writeStringLiteral(s) { + writer.writeStringLiteral(s); + } + function writeBase(s) { + writer.write(s); + } + function writeSymbol(s, sym) { + writer.writeSymbol(s, sym); + } + function writePunctuation(s) { + writer.writePunctuation(s); + } + function writeTrailingSemicolon() { + writer.writeTrailingSemicolon(";"); + } + function writeKeyword(s) { + writer.writeKeyword(s); + } + function writeOperator(s) { + writer.writeOperator(s); + } + function writeParameter(s) { + writer.writeParameter(s); + } + function writeComment(s) { + writer.writeComment(s); + } + function writeSpace() { + writer.writeSpace(" "); + } + function writeProperty(s) { + writer.writeProperty(s); + } + function writeLine() { + writer.writeLine(); + } + function increaseIndent() { + writer.increaseIndent(); + } + function decreaseIndent() { + writer.decreaseIndent(); + } + function writeToken(token, pos, writer, contextNode) { + return !sourceMapsDisabled + ? emitTokenWithSourceMap(contextNode, token, writer, pos, writeTokenText) + : writeTokenText(token, writer, pos); + } + function writeTokenNode(node, writer) { + if (onBeforeEmitToken) { + onBeforeEmitToken(node); + } + writer(ts.tokenToString(node.kind)); + if (onAfterEmitToken) { + onAfterEmitToken(node); + } + } + function writeTokenText(token, writer, pos) { + var tokenString = ts.tokenToString(token); + writer(tokenString); + return pos < 0 ? pos : pos + tokenString.length; + } + function writeLineOrSpace(node) { + if (ts.getEmitFlags(node) & 1) { + writeSpace(); + } + else { + writeLine(); + } + } + function writeLines(text) { + var lines = text.split(/\r\n?|\n/g); + var indentation = ts.guessIndentation(lines); + for (var _a = 0, lines_3 = lines; _a < lines_3.length; _a++) { + var lineText = lines_3[_a]; + var line = indentation ? lineText.slice(indentation) : lineText; + if (line.length) { + writeLine(); + write(line); + } + } + } + function increaseIndentIf(value, writeSpaceIfNotIndenting) { + if (value) { + increaseIndent(); + writeLine(); + } + else if (writeSpaceIfNotIndenting) { + writeSpace(); + } + } + function decreaseIndentIf(value1, value2) { + if (value1) { + decreaseIndent(); + } + if (value2) { + decreaseIndent(); + } + } + function shouldWriteLeadingLineTerminator(parentNode, children, format) { + if (format & 1) { + return true; + } + if (format & 2) { + if (format & 65536) { + return true; + } + var firstChild = children[0]; + if (firstChild === undefined) { + return !ts.rangeIsOnSingleLine(parentNode, currentSourceFile); + } + else if (ts.positionIsSynthesized(parentNode.pos) || ts.nodeIsSynthesized(firstChild)) { + return synthesizedNodeStartsOnNewLine(firstChild, format); + } + else { + return !ts.rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile); + } + } + else { + return false; + } + } + function shouldWriteSeparatingLineTerminator(previousNode, nextNode, format) { + if (format & 1) { + return true; + } + else if (format & 2) { + if (previousNode === undefined || nextNode === undefined) { + return false; + } + else if (ts.nodeIsSynthesized(previousNode) || ts.nodeIsSynthesized(nextNode)) { + return synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format); + } + else { + return !ts.rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile); + } + } + else { + return ts.getStartsOnNewLine(nextNode); + } + } + function shouldWriteClosingLineTerminator(parentNode, children, format) { + if (format & 1) { + return (format & 131072) === 0; + } + else if (format & 2) { + if (format & 65536) { + return true; + } + var lastChild = ts.lastOrUndefined(children); + if (lastChild === undefined) { + return !ts.rangeIsOnSingleLine(parentNode, currentSourceFile); + } + else if (ts.positionIsSynthesized(parentNode.pos) || ts.nodeIsSynthesized(lastChild)) { + return synthesizedNodeStartsOnNewLine(lastChild, format); + } + else { + return !ts.rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile); + } + } + else { + return false; + } + } + function synthesizedNodeStartsOnNewLine(node, format) { + if (ts.nodeIsSynthesized(node)) { + var startsOnNewLine = ts.getStartsOnNewLine(node); + if (startsOnNewLine === undefined) { + return (format & 65536) !== 0; + } + return startsOnNewLine; + } + return (format & 65536) !== 0; + } + function needsIndentation(parent, node1, node2) { + if (ts.getEmitFlags(parent) & 131072) { + return false; + } + parent = skipSynthesizedParentheses(parent); + node1 = skipSynthesizedParentheses(node1); + node2 = skipSynthesizedParentheses(node2); + if (ts.getStartsOnNewLine(node2)) { + return true; + } + return !ts.nodeIsSynthesized(parent) + && !ts.nodeIsSynthesized(node1) + && !ts.nodeIsSynthesized(node2) + && !ts.rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile); + } + function isEmptyBlock(block) { + return block.statements.length === 0 + && ts.rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile); + } + function skipSynthesizedParentheses(node) { + while (node.kind === 200 && ts.nodeIsSynthesized(node)) { + node = node.expression; + } + return node; + } + function getTextOfNode(node, includeTrivia) { + if (ts.isGeneratedIdentifier(node)) { + return generateName(node); + } + else if ((ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) && (ts.nodeIsSynthesized(node) || !node.parent || !currentSourceFile || (node.parent && currentSourceFile && ts.getSourceFileOfNode(node) !== ts.getOriginalNode(currentSourceFile)))) { + return ts.idText(node); + } + else if (node.kind === 10 && node.textSourceNode) { + return getTextOfNode(node.textSourceNode, includeTrivia); + } + else if (ts.isLiteralExpression(node) && (ts.nodeIsSynthesized(node) || !node.parent)) { + return node.text; + } + return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia); + } + function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) { + if (node.kind === 10 && node.textSourceNode) { + var textSourceNode = node.textSourceNode; + if (ts.isIdentifier(textSourceNode)) { + return jsxAttributeEscape ? "\"" + ts.escapeJsxAttributeString(getTextOfNode(textSourceNode)) + "\"" : + neverAsciiEscape || (ts.getEmitFlags(node) & 16777216) ? "\"" + ts.escapeString(getTextOfNode(textSourceNode)) + "\"" : + "\"" + ts.escapeNonAsciiString(getTextOfNode(textSourceNode)) + "\""; + } + else { + return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape); + } + } + return ts.getLiteralText(node, currentSourceFile, neverAsciiEscape, jsxAttributeEscape); + } + function pushNameGenerationScope(node) { + if (node && ts.getEmitFlags(node) & 524288) { + return; + } + tempFlagsStack.push(tempFlags); + tempFlags = 0; + reservedNamesStack.push(reservedNames); + } + function popNameGenerationScope(node) { + if (node && ts.getEmitFlags(node) & 524288) { + return; + } + tempFlags = tempFlagsStack.pop(); + reservedNames = reservedNamesStack.pop(); + } + function reserveNameInNestedScopes(name) { + if (!reservedNames || reservedNames === ts.lastOrUndefined(reservedNamesStack)) { + reservedNames = ts.createMap(); + } + reservedNames.set(name, true); + } + function generateNames(node) { + if (!node) + return; + switch (node.kind) { + case 223: + ts.forEach(node.statements, generateNames); + break; + case 238: + case 236: + case 228: + case 229: + generateNames(node.statement); + break; + case 227: + generateNames(node.thenStatement); + generateNames(node.elseStatement); + break; + case 230: + case 232: + case 231: + generateNames(node.initializer); + generateNames(node.statement); + break; + case 237: + generateNames(node.caseBlock); + break; + case 251: + ts.forEach(node.clauses, generateNames); + break; + case 277: + case 278: + ts.forEach(node.statements, generateNames); + break; + case 240: + generateNames(node.tryBlock); + generateNames(node.catchClause); + generateNames(node.finallyBlock); + break; + case 280: + generateNames(node.variableDeclaration); + generateNames(node.block); + break; + case 225: + generateNames(node.declarationList); + break; + case 243: + ts.forEach(node.declarations, generateNames); + break; + case 242: + case 156: + case 191: + case 245: + generateNameIfNeeded(node.name); + break; + case 244: + generateNameIfNeeded(node.name); + if (ts.getEmitFlags(node) & 524288) { + ts.forEach(node.parameters, generateNames); + generateNames(node.body); + } + break; + case 189: + case 190: + ts.forEach(node.elements, generateNames); + break; + case 254: + generateNames(node.importClause); + break; + case 255: + generateNameIfNeeded(node.name); + generateNames(node.namedBindings); + break; + case 256: + generateNameIfNeeded(node.name); + break; + case 262: + generateNameIfNeeded(node.name); + break; + case 257: + ts.forEach(node.elements, generateNames); + break; + case 258: + generateNameIfNeeded(node.propertyName || node.name); + break; + } + } + function generateMemberNames(node) { + if (!node) + return; + switch (node.kind) { + case 281: + case 282: + case 159: + case 161: + case 163: + case 164: + generateNameIfNeeded(node.name); + break; + } + } + function generateNameIfNeeded(name) { + if (name) { + if (ts.isGeneratedIdentifier(name)) { + generateName(name); + } + else if (ts.isBindingPattern(name)) { + generateNames(name); + } + } + } + function generateName(name) { + if ((name.autoGenerateFlags & 7) === 4) { + return generateNameCached(getNodeForGeneratedName(name), name.autoGenerateFlags); + } + else { + var autoGenerateId = name.autoGenerateId; + return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = makeName(name)); + } + } + function generateNameCached(node, flags) { + var nodeId = ts.getNodeId(node); + return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, flags)); + } + function isUniqueName(name) { + return isFileLevelUniqueName(name) + && !generatedNames.has(name) + && !(reservedNames && reservedNames.has(name)); + } + function isFileLevelUniqueName(name) { + return currentSourceFile ? ts.isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true; + } + function isUniqueLocalName(name, container) { + for (var node = container; ts.isNodeDescendantOf(node, container); node = node.nextContainer) { + if (node.locals) { + var local = node.locals.get(ts.escapeLeadingUnderscores(name)); + if (local && local.flags & (111551 | 1048576 | 2097152)) { + return false; + } + } + } + return true; + } + function makeTempVariableName(flags, reservedInNestedScopes) { + if (flags && !(tempFlags & flags)) { + var name = flags === 268435456 ? "_i" : "_n"; + if (isUniqueName(name)) { + tempFlags |= flags; + if (reservedInNestedScopes) { + reserveNameInNestedScopes(name); + } + return name; + } + } + while (true) { + var count = tempFlags & 268435455; + tempFlags++; + if (count !== 8 && count !== 13) { + var name = count < 26 + ? "_" + String.fromCharCode(97 + count) + : "_" + (count - 26); + if (isUniqueName(name)) { + if (reservedInNestedScopes) { + reserveNameInNestedScopes(name); + } + return name; + } + } + } + } + function makeUniqueName(baseName, checkFn, optimistic, scoped) { + if (checkFn === void 0) { checkFn = isUniqueName; } + if (optimistic) { + if (checkFn(baseName)) { + if (scoped) { + reserveNameInNestedScopes(baseName); + } + else { + generatedNames.set(baseName, true); + } + return baseName; + } + } + if (baseName.charCodeAt(baseName.length - 1) !== 95) { + baseName += "_"; + } + var i = 1; + while (true) { + var generatedName = baseName + i; + if (checkFn(generatedName)) { + if (scoped) { + reserveNameInNestedScopes(generatedName); + } + else { + generatedNames.set(generatedName, true); + } + return generatedName; + } + i++; + } + } + function makeFileLevelOptimisticUniqueName(name) { + return makeUniqueName(name, isFileLevelUniqueName, true); + } + function generateNameForModuleOrEnum(node) { + var name = getTextOfNode(node.name); + return isUniqueLocalName(name, node) ? name : makeUniqueName(name); + } + function generateNameForImportOrExportDeclaration(node) { + var expr = ts.getExternalModuleName(node); + var baseName = ts.isStringLiteral(expr) ? + ts.makeIdentifierFromModuleName(expr.text) : "module"; + return makeUniqueName(baseName); + } + function generateNameForExportDefault() { + return makeUniqueName("default"); + } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } + function generateNameForMethodOrAccessor(node) { + if (ts.isIdentifier(node.name)) { + return generateNameCached(node.name); + } + return makeTempVariableName(0); + } + function generateNameForNode(node, flags) { + switch (node.kind) { + case 75: + return makeUniqueName(getTextOfNode(node), isUniqueName, !!(flags & 16), !!(flags & 8)); + case 249: + case 248: + return generateNameForModuleOrEnum(node); + case 254: + case 260: + return generateNameForImportOrExportDeclaration(node); + case 244: + case 245: + case 259: + return generateNameForExportDefault(); + case 214: + return generateNameForClassExpression(); + case 161: + case 163: + case 164: + return generateNameForMethodOrAccessor(node); + case 154: + return makeTempVariableName(0, true); + default: + return makeTempVariableName(0); + } + } + function makeName(name) { + switch (name.autoGenerateFlags & 7) { + case 1: + return makeTempVariableName(0, !!(name.autoGenerateFlags & 8)); + case 2: + return makeTempVariableName(268435456, !!(name.autoGenerateFlags & 8)); + case 3: + return makeUniqueName(ts.idText(name), (name.autoGenerateFlags & 32) ? isFileLevelUniqueName : isUniqueName, !!(name.autoGenerateFlags & 16), !!(name.autoGenerateFlags & 8)); + } + return ts.Debug.fail("Unsupported GeneratedIdentifierKind."); + } + function getNodeForGeneratedName(name) { + var autoGenerateId = name.autoGenerateId; + var node = name; + var original = node.original; + while (original) { + node = original; + if (ts.isIdentifier(node) + && !!(node.autoGenerateFlags & 4) + && node.autoGenerateId !== autoGenerateId) { + break; + } + original = node.original; + } + return node; + } + function pipelineEmitWithComments(hint, node) { + ts.Debug.assert(lastNode === node || lastSubstitution === node); + enterComment(); + hasWrittenComment = false; + var emitFlags = ts.getEmitFlags(node); + var _a = ts.getCommentRange(node), pos = _a.pos, end = _a.end; + var isEmittedNode = node.kind !== 324; + var skipLeadingComments = pos < 0 || (emitFlags & 512) !== 0 || node.kind === 11; + var skipTrailingComments = end < 0 || (emitFlags & 1024) !== 0 || node.kind === 11; + var savedContainerPos = containerPos; + var savedContainerEnd = containerEnd; + var savedDeclarationListContainerEnd = declarationListContainerEnd; + if ((pos > 0 || end > 0) && pos !== end) { + if (!skipLeadingComments) { + emitLeadingComments(pos, isEmittedNode); + } + if (!skipLeadingComments || (pos >= 0 && (emitFlags & 512) !== 0)) { + containerPos = pos; + } + if (!skipTrailingComments || (end >= 0 && (emitFlags & 1024) !== 0)) { + containerEnd = end; + if (node.kind === 243) { + declarationListContainerEnd = end; + } + } + } + ts.forEach(ts.getSyntheticLeadingComments(node), emitLeadingSynthesizedComment); + exitComment(); + var pipelinePhase = getNextPipelinePhase(2, hint, node); + if (emitFlags & 2048) { + commentsDisabled = true; + pipelinePhase(hint, node); + commentsDisabled = false; + } + else { + pipelinePhase(hint, node); + } + enterComment(); + ts.forEach(ts.getSyntheticTrailingComments(node), emitTrailingSynthesizedComment); + if ((pos > 0 || end > 0) && pos !== end) { + containerPos = savedContainerPos; + containerEnd = savedContainerEnd; + declarationListContainerEnd = savedDeclarationListContainerEnd; + if (!skipTrailingComments && isEmittedNode) { + emitTrailingComments(end); + } + } + exitComment(); + ts.Debug.assert(lastNode === node || lastSubstitution === node); + } + function emitLeadingSynthesizedComment(comment) { + if (comment.kind === 2) { + writer.writeLine(); + } + writeSynthesizedComment(comment); + if (comment.hasTrailingNewLine || comment.kind === 2) { + writer.writeLine(); + } + else { + writer.writeSpace(" "); + } + } + function emitTrailingSynthesizedComment(comment) { + if (!writer.isAtStartOfLine()) { + writer.writeSpace(" "); + } + writeSynthesizedComment(comment); + if (comment.hasTrailingNewLine) { + writer.writeLine(); + } + } + function writeSynthesizedComment(comment) { + var text = formatSynthesizedComment(comment); + var lineMap = comment.kind === 3 ? ts.computeLineStarts(text) : undefined; + ts.writeCommentRange(text, lineMap, writer, 0, text.length, newLine); + } + function formatSynthesizedComment(comment) { + return comment.kind === 3 + ? "/*" + comment.text + "*/" + : "//" + comment.text; + } + function emitBodyWithDetachedComments(node, detachedRange, emitCallback) { + enterComment(); + var pos = detachedRange.pos, end = detachedRange.end; + var emitFlags = ts.getEmitFlags(node); + var skipLeadingComments = pos < 0 || (emitFlags & 512) !== 0; + var skipTrailingComments = commentsDisabled || end < 0 || (emitFlags & 1024) !== 0; + if (!skipLeadingComments) { + emitDetachedCommentsAndUpdateCommentsInfo(detachedRange); + } + exitComment(); + if (emitFlags & 2048 && !commentsDisabled) { + commentsDisabled = true; + emitCallback(node); + commentsDisabled = false; + } + else { + emitCallback(node); + } + enterComment(); + if (!skipTrailingComments) { + emitLeadingComments(detachedRange.end, true); + if (hasWrittenComment && !writer.isAtStartOfLine()) { + writer.writeLine(); + } + } + exitComment(); + } + function emitLeadingComments(pos, isEmittedNode) { + hasWrittenComment = false; + if (isEmittedNode) { + forEachLeadingCommentToEmit(pos, emitLeadingComment); + } + else if (pos === 0) { + forEachLeadingCommentToEmit(pos, emitTripleSlashLeadingComment); + } + } + function emitTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) { + if (isTripleSlashComment(commentPos, commentEnd)) { + emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos); + } + } + function shouldWriteComment(text, pos) { + if (printerOptions.onlyPrintJsDocStyle) { + return (ts.isJSDocLikeText(text, pos) || ts.isPinnedComment(text, pos)); + } + return true; + } + function emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) { + if (!shouldWriteComment(currentSourceFile.text, commentPos)) + return; + if (!hasWrittenComment) { + ts.emitNewLineBeforeLeadingCommentOfPosition(getCurrentLineMap(), writer, rangePos, commentPos); + hasWrittenComment = true; + } + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + else if (kind === 3) { + writer.writeSpace(" "); + } + } + function emitLeadingCommentsOfPosition(pos) { + if (commentsDisabled || pos === -1) { + return; + } + emitLeadingComments(pos, true); + } + function emitTrailingComments(pos) { + forEachTrailingCommentToEmit(pos, emitTrailingComment); + } + function emitTrailingComment(commentPos, commentEnd, _kind, hasTrailingNewLine) { + if (!shouldWriteComment(currentSourceFile.text, commentPos)) + return; + if (!writer.isAtStartOfLine()) { + writer.writeSpace(" "); + } + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + } + function emitTrailingCommentsOfPosition(pos, prefixSpace) { + if (commentsDisabled) { + return; + } + enterComment(); + forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : emitTrailingCommentOfPosition); + exitComment(); + } + function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) { + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + else { + writer.writeSpace(" "); + } + } + function forEachLeadingCommentToEmit(pos, cb) { + if (currentSourceFile && (containerPos === -1 || pos !== containerPos)) { + if (hasDetachedComments(pos)) { + forEachLeadingCommentWithoutDetachedComments(cb); + } + else { + ts.forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos); + } + } + } + function forEachTrailingCommentToEmit(end, cb) { + if (currentSourceFile && (containerEnd === -1 || (end !== containerEnd && end !== declarationListContainerEnd))) { + ts.forEachTrailingCommentRange(currentSourceFile.text, end, cb); + } + } + function hasDetachedComments(pos) { + return detachedCommentsInfo !== undefined && ts.last(detachedCommentsInfo).nodePos === pos; + } + function forEachLeadingCommentWithoutDetachedComments(cb) { + var pos = ts.last(detachedCommentsInfo).detachedCommentEndPos; + if (detachedCommentsInfo.length - 1) { + detachedCommentsInfo.pop(); + } + else { + detachedCommentsInfo = undefined; + } + ts.forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos); + } + function emitDetachedCommentsAndUpdateCommentsInfo(range) { + var currentDetachedCommentInfo = ts.emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled); + if (currentDetachedCommentInfo) { + if (detachedCommentsInfo) { + detachedCommentsInfo.push(currentDetachedCommentInfo); + } + else { + detachedCommentsInfo = [currentDetachedCommentInfo]; + } + } + } + function emitComment(text, lineMap, writer, commentPos, commentEnd, newLine) { + if (!shouldWriteComment(currentSourceFile.text, commentPos)) + return; + emitPos(commentPos); + ts.writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + } + function isTripleSlashComment(commentPos, commentEnd) { + return ts.isRecognizedTripleSlashComment(currentSourceFile.text, commentPos, commentEnd); + } + function getParsedSourceMap(node) { + if (node.parsedSourceMap === undefined && node.sourceMapText !== undefined) { + node.parsedSourceMap = ts.tryParseRawSourceMap(node.sourceMapText) || false; + } + return node.parsedSourceMap || undefined; + } + function pipelineEmitWithSourceMap(hint, node) { + ts.Debug.assert(lastNode === node || lastSubstitution === node); + var pipelinePhase = getNextPipelinePhase(3, hint, node); + if (ts.isUnparsedSource(node) || ts.isUnparsedPrepend(node)) { + pipelinePhase(hint, node); + } + else if (ts.isUnparsedNode(node)) { + var parsed = getParsedSourceMap(node.parent); + if (parsed && sourceMapGenerator) { + sourceMapGenerator.appendSourceMap(writer.getLine(), writer.getColumn(), parsed, node.parent.sourceMapPath, node.parent.getLineAndCharacterOfPosition(node.pos), node.parent.getLineAndCharacterOfPosition(node.end)); + } + pipelinePhase(hint, node); + } + else { + var _a = ts.getSourceMapRange(node), pos = _a.pos, end = _a.end, _b = _a.source, source = _b === void 0 ? sourceMapSource : _b; + var emitFlags = ts.getEmitFlags(node); + if (node.kind !== 324 + && (emitFlags & 16) === 0 + && pos >= 0) { + emitSourcePos(source, skipSourceTrivia(source, pos)); + } + if (emitFlags & 64) { + sourceMapsDisabled = true; + pipelinePhase(hint, node); + sourceMapsDisabled = false; + } + else { + pipelinePhase(hint, node); + } + if (node.kind !== 324 + && (emitFlags & 32) === 0 + && end >= 0) { + emitSourcePos(source, end); + } + } + ts.Debug.assert(lastNode === node || lastSubstitution === node); + } + function skipSourceTrivia(source, pos) { + return source.skipTrivia ? source.skipTrivia(pos) : ts.skipTrivia(source.text, pos); + } + function emitPos(pos) { + if (sourceMapsDisabled || ts.positionIsSynthesized(pos) || isJsonSourceMapSource(sourceMapSource)) { + return; + } + var _a = ts.getLineAndCharacterOfPosition(sourceMapSource, pos), sourceLine = _a.line, sourceCharacter = _a.character; + sourceMapGenerator.addMapping(writer.getLine(), writer.getColumn(), sourceMapSourceIndex, sourceLine, sourceCharacter, undefined); + } + function emitSourcePos(source, pos) { + if (source !== sourceMapSource) { + var savedSourceMapSource = sourceMapSource; + setSourceMapSource(source); + emitPos(pos); + setSourceMapSource(savedSourceMapSource); + } + else { + emitPos(pos); + } + } + function emitTokenWithSourceMap(node, token, writer, tokenPos, emitCallback) { + if (sourceMapsDisabled || node && ts.isInJsonFile(node)) { + return emitCallback(token, writer, tokenPos); + } + var emitNode = node && node.emitNode; + var emitFlags = emitNode && emitNode.flags || 0; + var range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token]; + var source = range && range.source || sourceMapSource; + tokenPos = skipSourceTrivia(source, range ? range.pos : tokenPos); + if ((emitFlags & 128) === 0 && tokenPos >= 0) { + emitSourcePos(source, tokenPos); + } + tokenPos = emitCallback(token, writer, tokenPos); + if (range) + tokenPos = range.end; + if ((emitFlags & 256) === 0 && tokenPos >= 0) { + emitSourcePos(source, tokenPos); + } + return tokenPos; + } + function setSourceMapSource(source) { + if (sourceMapsDisabled) { + return; + } + sourceMapSource = source; + if (isJsonSourceMapSource(source)) { + return; + } + sourceMapSourceIndex = sourceMapGenerator.addSource(source.fileName); + if (printerOptions.inlineSources) { + sourceMapGenerator.setSourceContent(sourceMapSourceIndex, source.text); + } + } + function isJsonSourceMapSource(sourceFile) { + return ts.fileExtensionIs(sourceFile.fileName, ".json"); + } + } + ts.createPrinter = createPrinter; + function createBracketsMap() { + var brackets = []; + brackets[1024] = ["{", "}"]; + brackets[2048] = ["(", ")"]; + brackets[4096] = ["<", ">"]; + brackets[8192] = ["[", "]"]; + return brackets; + } + function getOpeningBracket(format) { + return brackets[format & 15360][0]; + } + function getClosingBracket(format) { + return brackets[format & 15360][1]; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames) { + if (!host.getDirectories || !host.readDirectory) { + return undefined; + } + var cachedReadDirectoryResult = ts.createMap(); + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return { + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + fileExists: fileExists, + readFile: function (path, encoding) { return host.readFile(path, encoding); }, + directoryExists: host.directoryExists && directoryExists, + getDirectories: getDirectories, + readDirectory: readDirectory, + createDirectory: host.createDirectory && createDirectory, + writeFile: host.writeFile && writeFile, + addOrDeleteFileOrDirectory: addOrDeleteFileOrDirectory, + addOrDeleteFile: addOrDeleteFile, + clearCache: clearCache, + realpath: host.realpath && realpath + }; + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function getCachedFileSystemEntries(rootDirPath) { + return cachedReadDirectoryResult.get(ts.ensureTrailingDirectorySeparator(rootDirPath)); + } + function getCachedFileSystemEntriesForBaseDir(path) { + return getCachedFileSystemEntries(ts.getDirectoryPath(path)); + } + function getBaseNameOfFileName(fileName) { + return ts.getBaseFileName(ts.normalizePath(fileName)); + } + function createCachedFileSystemEntries(rootDir, rootDirPath) { + var resultFromHost = { + files: ts.map(host.readDirectory(rootDir, undefined, undefined, ["*.*"]), getBaseNameOfFileName) || [], + directories: host.getDirectories(rootDir) || [] + }; + cachedReadDirectoryResult.set(ts.ensureTrailingDirectorySeparator(rootDirPath), resultFromHost); + return resultFromHost; + } + function tryReadDirectory(rootDir, rootDirPath) { + rootDirPath = ts.ensureTrailingDirectorySeparator(rootDirPath); + var cachedResult = getCachedFileSystemEntries(rootDirPath); + if (cachedResult) { + return cachedResult; + } + try { + return createCachedFileSystemEntries(rootDir, rootDirPath); + } + catch (_e) { + ts.Debug.assert(!cachedReadDirectoryResult.has(ts.ensureTrailingDirectorySeparator(rootDirPath))); + return undefined; + } + } + function fileNameEqual(name1, name2) { + return getCanonicalFileName(name1) === getCanonicalFileName(name2); + } + function hasEntry(entries, name) { + return ts.some(entries, function (file) { return fileNameEqual(file, name); }); + } + function updateFileSystemEntry(entries, baseName, isValid) { + if (hasEntry(entries, baseName)) { + if (!isValid) { + return ts.filterMutate(entries, function (entry) { return !fileNameEqual(entry, baseName); }); + } + } + else if (isValid) { + return entries.push(baseName); + } + } + function writeFile(fileName, data, writeByteOrderMark) { + var path = toPath(fileName); + var result = getCachedFileSystemEntriesForBaseDir(path); + if (result) { + updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), true); + } + return host.writeFile(fileName, data, writeByteOrderMark); + } + function fileExists(fileName) { + var path = toPath(fileName); + var result = getCachedFileSystemEntriesForBaseDir(path); + return result && hasEntry(result.files, getBaseNameOfFileName(fileName)) || + host.fileExists(fileName); + } + function directoryExists(dirPath) { + var path = toPath(dirPath); + return cachedReadDirectoryResult.has(ts.ensureTrailingDirectorySeparator(path)) || host.directoryExists(dirPath); + } + function createDirectory(dirPath) { + var path = toPath(dirPath); + var result = getCachedFileSystemEntriesForBaseDir(path); + var baseFileName = getBaseNameOfFileName(dirPath); + if (result) { + updateFileSystemEntry(result.directories, baseFileName, true); + } + host.createDirectory(dirPath); + } + function getDirectories(rootDir) { + var rootDirPath = toPath(rootDir); + var result = tryReadDirectory(rootDir, rootDirPath); + if (result) { + return result.directories.slice(); + } + return host.getDirectories(rootDir); + } + function readDirectory(rootDir, extensions, excludes, includes, depth) { + var rootDirPath = toPath(rootDir); + var result = tryReadDirectory(rootDir, rootDirPath); + if (result) { + return ts.matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath); + } + return host.readDirectory(rootDir, extensions, excludes, includes, depth); + function getFileSystemEntries(dir) { + var path = toPath(dir); + if (path === rootDirPath) { + return result; + } + return tryReadDirectory(dir, path) || ts.emptyFileSystemEntries; + } + } + function realpath(s) { + return host.realpath ? host.realpath(s) : s; + } + function addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath) { + var existingResult = getCachedFileSystemEntries(fileOrDirectoryPath); + if (existingResult) { + clearCache(); + return undefined; + } + var parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath); + if (!parentResult) { + return undefined; + } + if (!host.directoryExists) { + clearCache(); + return undefined; + } + var baseName = getBaseNameOfFileName(fileOrDirectory); + var fsQueryResult = { + fileExists: host.fileExists(fileOrDirectoryPath), + directoryExists: host.directoryExists(fileOrDirectoryPath) + }; + if (fsQueryResult.directoryExists || hasEntry(parentResult.directories, baseName)) { + clearCache(); + } + else { + updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists); + } + return fsQueryResult; + } + function addOrDeleteFile(fileName, filePath, eventKind) { + if (eventKind === ts.FileWatcherEventKind.Changed) { + return; + } + var parentResult = getCachedFileSystemEntriesForBaseDir(filePath); + if (parentResult) { + updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === ts.FileWatcherEventKind.Created); + } + } + function updateFilesOfFileSystemEntry(parentResult, baseName, fileExists) { + updateFileSystemEntry(parentResult.files, baseName, fileExists); + } + function clearCache() { + cachedReadDirectoryResult.clear(); + } + } + ts.createCachedDirectoryStructureHost = createCachedDirectoryStructureHost; + var ConfigFileProgramReloadLevel; + (function (ConfigFileProgramReloadLevel) { + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["None"] = 0] = "None"; + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["Partial"] = 1] = "Partial"; + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["Full"] = 2] = "Full"; + })(ConfigFileProgramReloadLevel = ts.ConfigFileProgramReloadLevel || (ts.ConfigFileProgramReloadLevel = {})); + function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) { + var missingFilePaths = program.getMissingFilePaths(); + var newMissingFilePathMap = ts.arrayToSet(missingFilePaths); + ts.mutateMap(missingFileWatches, newMissingFilePathMap, { + createNewValue: createMissingFileWatch, + onDeleteValue: ts.closeFileWatcher + }); + } + ts.updateMissingFilePathsWatch = updateMissingFilePathsWatch; + function updateWatchingWildcardDirectories(existingWatchedForWildcards, wildcardDirectories, watchDirectory) { + ts.mutateMap(existingWatchedForWildcards, wildcardDirectories, { + createNewValue: createWildcardDirectoryWatcher, + onDeleteValue: closeFileWatcherOf, + onExistingValue: updateWildcardDirectoryWatcher + }); + function createWildcardDirectoryWatcher(directory, flags) { + return { + watcher: watchDirectory(directory, flags), + flags: flags + }; + } + function updateWildcardDirectoryWatcher(existingWatcher, flags, directory) { + if (existingWatcher.flags === flags) { + return; + } + existingWatcher.watcher.close(); + existingWatchedForWildcards.set(directory, createWildcardDirectoryWatcher(directory, flags)); + } + } + ts.updateWatchingWildcardDirectories = updateWatchingWildcardDirectories; + function isEmittedFileOfProgram(program, file) { + if (!program) { + return false; + } + return program.isEmittedFile(file); + } + ts.isEmittedFileOfProgram = isEmittedFileOfProgram; + var WatchLogLevel; + (function (WatchLogLevel) { + WatchLogLevel[WatchLogLevel["None"] = 0] = "None"; + WatchLogLevel[WatchLogLevel["TriggerOnly"] = 1] = "TriggerOnly"; + WatchLogLevel[WatchLogLevel["Verbose"] = 2] = "Verbose"; + })(WatchLogLevel = ts.WatchLogLevel || (ts.WatchLogLevel = {})); + function getWatchFactory(watchLogLevel, log, getDetailWatchInfo) { + return getWatchFactoryWith(watchLogLevel, log, getDetailWatchInfo, watchFile, watchDirectory); + } + ts.getWatchFactory = getWatchFactory; + function getWatchFactoryWith(watchLogLevel, log, getDetailWatchInfo, watchFile, watchDirectory) { + var createFileWatcher = getCreateFileWatcher(watchLogLevel, watchFile); + var createFilePathWatcher = watchLogLevel === WatchLogLevel.None ? watchFilePath : createFileWatcher; + var createDirectoryWatcher = getCreateFileWatcher(watchLogLevel, watchDirectory); + if (watchLogLevel === WatchLogLevel.Verbose && ts.sysLog === ts.noop) { + ts.setSysLog(function (s) { return log(s); }); + } + return { + watchFile: function (host, file, callback, pollingInterval, options, detailInfo1, detailInfo2) { + return createFileWatcher(host, file, callback, pollingInterval, options, undefined, detailInfo1, detailInfo2, watchFile, log, "FileWatcher", getDetailWatchInfo); + }, + watchFilePath: function (host, file, callback, pollingInterval, options, path, detailInfo1, detailInfo2) { + return createFilePathWatcher(host, file, callback, pollingInterval, options, path, detailInfo1, detailInfo2, watchFile, log, "FileWatcher", getDetailWatchInfo); + }, + watchDirectory: function (host, directory, callback, flags, options, detailInfo1, detailInfo2) { + return createDirectoryWatcher(host, directory, callback, flags, options, undefined, detailInfo1, detailInfo2, watchDirectory, log, "DirectoryWatcher", getDetailWatchInfo); + } + }; + } + function watchFile(host, file, callback, pollingInterval, options) { + return host.watchFile(file, callback, pollingInterval, options); + } + function watchFilePath(host, file, callback, pollingInterval, options, path) { + return watchFile(host, file, function (fileName, eventKind) { return callback(fileName, eventKind, path); }, pollingInterval, options); + } + function watchDirectory(host, directory, callback, flags, options) { + return host.watchDirectory(directory, callback, (flags & 1) !== 0, options); + } + function getCreateFileWatcher(watchLogLevel, addWatch) { + switch (watchLogLevel) { + case WatchLogLevel.None: + return addWatch; + case WatchLogLevel.TriggerOnly: + return createFileWatcherWithTriggerLogging; + case WatchLogLevel.Verbose: + return addWatch === watchDirectory ? createDirectoryWatcherWithLogging : createFileWatcherWithLogging; + } + } + function createFileWatcherWithLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { + log(watchCaption + ":: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + var watcher = createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo); + return { + close: function () { + log(watchCaption + ":: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + watcher.close(); + } + }; + } + function createDirectoryWatcherWithLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { + var watchInfo = watchCaption + ":: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(watchInfo); + var start = ts.timestamp(); + var watcher = createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo); + var elapsed = ts.timestamp() - start; + log("Elapsed:: " + elapsed + "ms " + watchInfo); + return { + close: function () { + var watchInfo = watchCaption + ":: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(watchInfo); + var start = ts.timestamp(); + watcher.close(); + var elapsed = ts.timestamp() - start; + log("Elapsed:: " + elapsed + "ms " + watchInfo); + } + }; + } + function createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { + return addWatch(host, file, function (fileName, cbOptional) { + var triggerredInfo = watchCaption + ":: Triggered with " + fileName + " " + (cbOptional !== undefined ? cbOptional : "") + ":: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(triggerredInfo); + var start = ts.timestamp(); + cb(fileName, cbOptional, passThrough); + var elapsed = ts.timestamp() - start; + log("Elapsed:: " + elapsed + "ms " + triggerredInfo); + }, flags, options); + } + function getFallbackOptions(options) { + var fallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchFile: fallbackPolling !== undefined ? + fallbackPolling : + ts.WatchFileKind.PriorityPollingInterval + }; + } + ts.getFallbackOptions = getFallbackOptions; + function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo) { + return "WatchInfo: " + file + " " + flags + " " + JSON.stringify(options) + " " + (getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : detailInfo1 + " " + detailInfo2); + } + function closeFileWatcherOf(objWithWatcher) { + objWithWatcher.watcher.close(); + } + ts.closeFileWatcherOf = closeFileWatcherOf; +})(ts || (ts = {})); +var ts; +(function (ts) { + var ignoreDiagnosticCommentRegEx = /(^\s*$)|(^\s*\/\/\/?\s*(@ts-ignore)?)/; + function findConfigFile(searchPath, fileExists, configName) { + if (configName === void 0) { configName = "tsconfig.json"; } + return ts.forEachAncestorDirectory(searchPath, function (ancestor) { + var fileName = ts.combinePaths(ancestor, configName); + return fileExists(fileName) ? fileName : undefined; + }); + } + ts.findConfigFile = findConfigFile; + function resolveTripleslashReference(moduleName, containingFile) { + var basePath = ts.getDirectoryPath(containingFile); + var referencedFileName = ts.isRootedDiskPath(moduleName) ? moduleName : ts.combinePaths(basePath, moduleName); + return ts.normalizePath(referencedFileName); + } + ts.resolveTripleslashReference = resolveTripleslashReference; + function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) { + var commonPathComponents; + var failed = ts.forEach(fileNames, function (sourceFile) { + var sourcePathComponents = ts.getNormalizedPathComponents(sourceFile, currentDirectory); + sourcePathComponents.pop(); + if (!commonPathComponents) { + commonPathComponents = sourcePathComponents; + return; + } + var n = Math.min(commonPathComponents.length, sourcePathComponents.length); + for (var i = 0; i < n; i++) { + if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) { + if (i === 0) { + return true; + } + commonPathComponents.length = i; + break; + } + } + if (sourcePathComponents.length < commonPathComponents.length) { + commonPathComponents.length = sourcePathComponents.length; + } + }); + if (failed) { + return ""; + } + if (!commonPathComponents) { + return currentDirectory; + } + return ts.getPathFromPathComponents(commonPathComponents); + } + ts.computeCommonSourceDirectoryOfFilenames = computeCommonSourceDirectoryOfFilenames; + function createCompilerHost(options, setParentNodes) { + return createCompilerHostWorker(options, setParentNodes); + } + ts.createCompilerHost = createCompilerHost; + function createCompilerHostWorker(options, setParentNodes, system) { + if (system === void 0) { system = ts.sys; } + var existingDirectories = ts.createMap(); + var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames); + function getSourceFile(fileName, languageVersion, onError) { + var text; + try { + ts.performance.mark("beforeIORead"); + text = compilerHost.readFile(fileName); + ts.performance.mark("afterIORead"); + ts.performance.measure("I/O Read", "beforeIORead", "afterIORead"); + } + catch (e) { + if (onError) { + onError(e.message); + } + text = ""; + } + return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined; + } + function directoryExists(directoryPath) { + if (existingDirectories.has(directoryPath)) { + return true; + } + if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) { + existingDirectories.set(directoryPath, true); + return true; + } + return false; + } + function writeFile(fileName, data, writeByteOrderMark, onError) { + try { + ts.performance.mark("beforeIOWrite"); + ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return writeFileWorker(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); }); + ts.performance.mark("afterIOWrite"); + ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite"); + } + catch (e) { + if (onError) { + onError(e.message); + } + } + } + var outputFingerprints; + function writeFileWorker(fileName, data, writeByteOrderMark) { + if (!ts.isWatchSet(options) || !system.createHash || !system.getModifiedTime) { + system.writeFile(fileName, data, writeByteOrderMark); + return; + } + if (!outputFingerprints) { + outputFingerprints = ts.createMap(); + } + var hash = system.createHash(data); + var mtimeBefore = system.getModifiedTime(fileName); + if (mtimeBefore) { + var fingerprint = outputFingerprints.get(fileName); + if (fingerprint && + fingerprint.byteOrderMark === writeByteOrderMark && + fingerprint.hash === hash && + fingerprint.mtime.getTime() === mtimeBefore.getTime()) { + return; + } + } + system.writeFile(fileName, data, writeByteOrderMark); + var mtimeAfter = system.getModifiedTime(fileName) || ts.missingFileModifiedTime; + outputFingerprints.set(fileName, { + hash: hash, + byteOrderMark: writeByteOrderMark, + mtime: mtimeAfter + }); + } + function getDefaultLibLocation() { + return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath())); + } + var newLine = ts.getNewLineCharacter(options, function () { return system.newLine; }); + var realpath = system.realpath && (function (path) { return system.realpath(path); }); + var compilerHost = { + getSourceFile: getSourceFile, + getDefaultLibLocation: getDefaultLibLocation, + getDefaultLibFileName: function (options) { return ts.combinePaths(getDefaultLibLocation(), ts.getDefaultLibFileName(options)); }, + writeFile: writeFile, + getCurrentDirectory: ts.memoize(function () { return system.getCurrentDirectory(); }), + useCaseSensitiveFileNames: function () { return system.useCaseSensitiveFileNames; }, + getCanonicalFileName: getCanonicalFileName, + getNewLine: function () { return newLine; }, + fileExists: function (fileName) { return system.fileExists(fileName); }, + readFile: function (fileName) { return system.readFile(fileName); }, + trace: function (s) { return system.write(s + newLine); }, + directoryExists: function (directoryName) { return system.directoryExists(directoryName); }, + getEnvironmentVariable: function (name) { return system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : ""; }, + getDirectories: function (path) { return system.getDirectories(path); }, + realpath: realpath, + readDirectory: function (path, extensions, include, exclude, depth) { return system.readDirectory(path, extensions, include, exclude, depth); }, + createDirectory: function (d) { return system.createDirectory(d); }, + createHash: ts.maybeBind(system, system.createHash) + }; + return compilerHost; + } + ts.createCompilerHostWorker = createCompilerHostWorker; + function changeCompilerHostLikeToUseCache(host, toPath, getSourceFile) { + var originalReadFile = host.readFile; + var originalFileExists = host.fileExists; + var originalDirectoryExists = host.directoryExists; + var originalCreateDirectory = host.createDirectory; + var originalWriteFile = host.writeFile; + var readFileCache = ts.createMap(); + var fileExistsCache = ts.createMap(); + var directoryExistsCache = ts.createMap(); + var sourceFileCache = ts.createMap(); + var readFileWithCache = function (fileName) { + var key = toPath(fileName); + var value = readFileCache.get(key); + if (value !== undefined) + return value !== false ? value : undefined; + return setReadFileCache(key, fileName); + }; + var setReadFileCache = function (key, fileName) { + var newValue = originalReadFile.call(host, fileName); + readFileCache.set(key, newValue !== undefined ? newValue : false); + return newValue; + }; + host.readFile = function (fileName) { + var key = toPath(fileName); + var value = readFileCache.get(key); + if (value !== undefined) + return value !== false ? value : undefined; + if (!ts.fileExtensionIs(fileName, ".json") && !ts.isBuildInfoFile(fileName)) { + return originalReadFile.call(host, fileName); + } + return setReadFileCache(key, fileName); + }; + var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersion, onError, shouldCreateNewSourceFile) { + var key = toPath(fileName); + var value = sourceFileCache.get(key); + if (value) + return value; + var sourceFile = getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile); + if (sourceFile && (ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json"))) { + sourceFileCache.set(key, sourceFile); + } + return sourceFile; + } : undefined; + host.fileExists = function (fileName) { + var key = toPath(fileName); + var value = fileExistsCache.get(key); + if (value !== undefined) + return value; + var newValue = originalFileExists.call(host, fileName); + fileExistsCache.set(key, !!newValue); + return newValue; + }; + if (originalWriteFile) { + host.writeFile = function (fileName, data, writeByteOrderMark, onError, sourceFiles) { + var key = toPath(fileName); + fileExistsCache.delete(key); + var value = readFileCache.get(key); + if (value !== undefined && value !== data) { + readFileCache.delete(key); + sourceFileCache.delete(key); + } + else if (getSourceFileWithCache) { + var sourceFile = sourceFileCache.get(key); + if (sourceFile && sourceFile.text !== data) { + sourceFileCache.delete(key); + } + } + originalWriteFile.call(host, fileName, data, writeByteOrderMark, onError, sourceFiles); + }; + } + if (originalDirectoryExists && originalCreateDirectory) { + host.directoryExists = function (directory) { + var key = toPath(directory); + var value = directoryExistsCache.get(key); + if (value !== undefined) + return value; + var newValue = originalDirectoryExists.call(host, directory); + directoryExistsCache.set(key, !!newValue); + return newValue; + }; + host.createDirectory = function (directory) { + var key = toPath(directory); + directoryExistsCache.delete(key); + originalCreateDirectory.call(host, directory); + }; + } + return { + originalReadFile: originalReadFile, + originalFileExists: originalFileExists, + originalDirectoryExists: originalDirectoryExists, + originalCreateDirectory: originalCreateDirectory, + originalWriteFile: originalWriteFile, + getSourceFileWithCache: getSourceFileWithCache, + readFileWithCache: readFileWithCache + }; + } + ts.changeCompilerHostLikeToUseCache = changeCompilerHostLikeToUseCache; + function getPreEmitDiagnostics(program, sourceFile, cancellationToken) { + var diagnostics; + diagnostics = ts.addRange(diagnostics, program.getConfigFileParsingDiagnostics()); + diagnostics = ts.addRange(diagnostics, program.getOptionsDiagnostics(cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile, cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getGlobalDiagnostics(cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getSemanticDiagnostics(sourceFile, cancellationToken)); + if (ts.getEmitDeclarations(program.getCompilerOptions())) { + diagnostics = ts.addRange(diagnostics, program.getDeclarationDiagnostics(sourceFile, cancellationToken)); + } + return ts.sortAndDeduplicateDiagnostics(diagnostics || ts.emptyArray); + } + ts.getPreEmitDiagnostics = getPreEmitDiagnostics; + function formatDiagnostics(diagnostics, host) { + var output = ""; + for (var _i = 0, diagnostics_2 = diagnostics; _i < diagnostics_2.length; _i++) { + var diagnostic = diagnostics_2[_i]; + output += formatDiagnostic(diagnostic, host); + } + return output; + } + ts.formatDiagnostics = formatDiagnostics; + function formatDiagnostic(diagnostic, host) { + var errorMessage = ts.diagnosticCategoryName(diagnostic) + " TS" + diagnostic.code + ": " + flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine()) + host.getNewLine(); + if (diagnostic.file) { + var _a = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), line = _a.line, character = _a.character; + var fileName = diagnostic.file.fileName; + var relativeFileName = ts.convertToRelativePath(fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); }); + return relativeFileName + "(" + (line + 1) + "," + (character + 1) + "): " + errorMessage; + } + return errorMessage; + } + ts.formatDiagnostic = formatDiagnostic; + var ForegroundColorEscapeSequences; + (function (ForegroundColorEscapeSequences) { + ForegroundColorEscapeSequences["Grey"] = "\u001B[90m"; + ForegroundColorEscapeSequences["Red"] = "\u001B[91m"; + ForegroundColorEscapeSequences["Yellow"] = "\u001B[93m"; + ForegroundColorEscapeSequences["Blue"] = "\u001B[94m"; + ForegroundColorEscapeSequences["Cyan"] = "\u001B[96m"; + })(ForegroundColorEscapeSequences = ts.ForegroundColorEscapeSequences || (ts.ForegroundColorEscapeSequences = {})); + var gutterStyleSequence = "\u001b[7m"; + var gutterSeparator = " "; + var resetEscapeSequence = "\u001b[0m"; + var ellipsis = "..."; + var halfIndent = " "; + var indent = " "; + function getCategoryFormat(category) { + switch (category) { + case ts.DiagnosticCategory.Error: return ForegroundColorEscapeSequences.Red; + case ts.DiagnosticCategory.Warning: return ForegroundColorEscapeSequences.Yellow; + case ts.DiagnosticCategory.Suggestion: return ts.Debug.fail("Should never get an Info diagnostic on the command line."); + case ts.DiagnosticCategory.Message: return ForegroundColorEscapeSequences.Blue; + } + } + function formatColorAndReset(text, formatStyle) { + return formatStyle + text + resetEscapeSequence; + } + ts.formatColorAndReset = formatColorAndReset; + function padLeft(s, length) { + while (s.length < length) { + s = " " + s; + } + return s; + } + function formatCodeSpan(file, start, length, indent, squiggleColor, host) { + var _a = ts.getLineAndCharacterOfPosition(file, start), firstLine = _a.line, firstLineChar = _a.character; + var _b = ts.getLineAndCharacterOfPosition(file, start + length), lastLine = _b.line, lastLineChar = _b.character; + var lastLineInFile = ts.getLineAndCharacterOfPosition(file, file.text.length).line; + var hasMoreThanFiveLines = (lastLine - firstLine) >= 4; + var gutterWidth = (lastLine + 1 + "").length; + if (hasMoreThanFiveLines) { + gutterWidth = Math.max(ellipsis.length, gutterWidth); + } + var context = ""; + for (var i = firstLine; i <= lastLine; i++) { + context += host.getNewLine(); + if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) { + context += indent + formatColorAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine(); + i = lastLine - 1; + } + var lineStart = ts.getPositionOfLineAndCharacter(file, i, 0); + var lineEnd = i < lastLineInFile ? ts.getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length; + var lineContent = file.text.slice(lineStart, lineEnd); + lineContent = lineContent.replace(/\s+$/g, ""); + lineContent = lineContent.replace("\t", " "); + context += indent + formatColorAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator; + context += lineContent + host.getNewLine(); + context += indent + formatColorAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator; + context += squiggleColor; + if (i === firstLine) { + var lastCharForLine = i === lastLine ? lastLineChar : undefined; + context += lineContent.slice(0, firstLineChar).replace(/\S/g, " "); + context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~"); + } + else if (i === lastLine) { + context += lineContent.slice(0, lastLineChar).replace(/./g, "~"); + } + else { + context += lineContent.replace(/./g, "~"); + } + context += resetEscapeSequence; + } + return context; + } + function formatLocation(file, start, host, color) { + if (color === void 0) { color = formatColorAndReset; } + var _a = ts.getLineAndCharacterOfPosition(file, start), firstLine = _a.line, firstLineChar = _a.character; + var relativeFileName = host ? ts.convertToRelativePath(file.fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); }) : file.fileName; + var output = ""; + output += color(relativeFileName, ForegroundColorEscapeSequences.Cyan); + output += ":"; + output += color("" + (firstLine + 1), ForegroundColorEscapeSequences.Yellow); + output += ":"; + output += color("" + (firstLineChar + 1), ForegroundColorEscapeSequences.Yellow); + return output; + } + ts.formatLocation = formatLocation; + function formatDiagnosticsWithColorAndContext(diagnostics, host) { + var output = ""; + for (var _i = 0, diagnostics_3 = diagnostics; _i < diagnostics_3.length; _i++) { + var diagnostic = diagnostics_3[_i]; + if (diagnostic.file) { + var file = diagnostic.file, start = diagnostic.start; + output += formatLocation(file, start, host); + output += " - "; + } + output += formatColorAndReset(ts.diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category)); + output += formatColorAndReset(" TS" + diagnostic.code + ": ", ForegroundColorEscapeSequences.Grey); + output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine()); + if (diagnostic.file) { + output += host.getNewLine(); + output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", getCategoryFormat(diagnostic.category), host); + if (diagnostic.relatedInformation) { + output += host.getNewLine(); + for (var _a = 0, _b = diagnostic.relatedInformation; _a < _b.length; _a++) { + var _c = _b[_a], file = _c.file, start = _c.start, length_7 = _c.length, messageText = _c.messageText; + if (file) { + output += host.getNewLine(); + output += halfIndent + formatLocation(file, start, host); + output += formatCodeSpan(file, start, length_7, indent, ForegroundColorEscapeSequences.Cyan, host); + } + output += host.getNewLine(); + output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine()); + } + } + } + output += host.getNewLine(); + } + return output; + } + ts.formatDiagnosticsWithColorAndContext = formatDiagnosticsWithColorAndContext; + function flattenDiagnosticMessageText(diag, newLine, indent) { + if (indent === void 0) { indent = 0; } + if (ts.isString(diag)) { + return diag; + } + else if (diag === undefined) { + return ""; + } + var result = ""; + if (indent) { + result += newLine; + for (var i = 0; i < indent; i++) { + result += " "; + } + } + result += diag.messageText; + indent++; + if (diag.next) { + for (var _i = 0, _a = diag.next; _i < _a.length; _i++) { + var kid = _a[_i]; + result += flattenDiagnosticMessageText(kid, newLine, indent); + } + } + return result; + } + ts.flattenDiagnosticMessageText = flattenDiagnosticMessageText; + function loadWithLocalCache(names, containingFile, redirectedReference, loader) { + if (names.length === 0) { + return []; + } + var resolutions = []; + var cache = ts.createMap(); + for (var _i = 0, names_2 = names; _i < names_2.length; _i++) { + var name = names_2[_i]; + var result = void 0; + if (cache.has(name)) { + result = cache.get(name); + } + else { + cache.set(name, result = loader(name, containingFile, redirectedReference)); + } + resolutions.push(result); + } + return resolutions; + } + ts.loadWithLocalCache = loadWithLocalCache; + ts.inferredTypesContainingFile = "__inferred type names__.ts"; + function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, projectReferences) { + if (!program || hasChangedAutomaticTypeDirectiveNames) { + return false; + } + if (!ts.arrayIsEqualTo(program.getRootFileNames(), rootFileNames)) { + return false; + } + var seenResolvedRefs; + if (!ts.arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate)) { + return false; + } + if (program.getSourceFiles().some(sourceFileNotUptoDate)) { + return false; + } + if (program.getMissingFilePaths().some(fileExists)) { + return false; + } + var currentOptions = program.getCompilerOptions(); + if (!ts.compareDataObjects(currentOptions, newOptions)) { + return false; + } + if (currentOptions.configFile && newOptions.configFile) { + return currentOptions.configFile.text === newOptions.configFile.text; + } + return true; + function sourceFileNotUptoDate(sourceFile) { + return !sourceFileVersionUptoDate(sourceFile) || + hasInvalidatedResolution(sourceFile.path); + } + function sourceFileVersionUptoDate(sourceFile) { + return sourceFile.version === getSourceVersion(sourceFile.resolvedPath); + } + function projectReferenceUptoDate(oldRef, newRef, index) { + if (!ts.projectReferenceIsEqualTo(oldRef, newRef)) { + return false; + } + return resolvedProjectReferenceUptoDate(program.getResolvedProjectReferences()[index], oldRef); + } + function resolvedProjectReferenceUptoDate(oldResolvedRef, oldRef) { + if (oldResolvedRef) { + if (ts.contains(seenResolvedRefs, oldResolvedRef)) { + return true; + } + if (!sourceFileVersionUptoDate(oldResolvedRef.sourceFile)) { + return false; + } + (seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef); + return !ts.forEach(oldResolvedRef.references, function (childResolvedRef, index) { + return !resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences[index]); + }); + } + return !fileExists(resolveProjectReferencePath(oldRef)); + } + } + ts.isProgramUptoDate = isProgramUptoDate; + function getConfigFileParsingDiagnostics(configFileParseResult) { + return configFileParseResult.options.configFile ? __spreadArrays(configFileParseResult.options.configFile.parseDiagnostics, configFileParseResult.errors) : + configFileParseResult.errors; + } + ts.getConfigFileParsingDiagnostics = getConfigFileParsingDiagnostics; + function shouldProgramCreateNewSourceFiles(program, newOptions) { + if (!program) + return false; + var oldOptions = program.getCompilerOptions(); + return !!ts.sourceFileAffectingCompilerOptions.some(function (option) { + return !ts.isJsonEqual(ts.getCompilerOptionValue(oldOptions, option), ts.getCompilerOptionValue(newOptions, option)); + }); + } + function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics) { + return { + rootNames: rootNames, + options: options, + host: host, + oldProgram: oldProgram, + configFileParsingDiagnostics: configFileParsingDiagnostics + }; + } + function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) { + var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; + var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences; + var oldProgram = createProgramOptions.oldProgram; + var processingDefaultLibFiles; + var processingOtherFiles; + var files; + var symlinks; + var commonSourceDirectory; + var diagnosticsProducingTypeChecker; + var noDiagnosticsTypeChecker; + var classifiableNames; + var ambientModuleNameToUnmodifiedFileName = ts.createMap(); + var refFileMap; + var cachedBindAndCheckDiagnosticsForFile = {}; + var cachedDeclarationDiagnosticsForFile = {}; + var resolvedTypeReferenceDirectives = ts.createMap(); + var fileProcessingDiagnostics = ts.createDiagnosticCollection(); + var maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0; + var currentNodeModulesDepth = 0; + var modulesWithElidedImports = ts.createMap(); + var sourceFilesFoundSearchingNodeModules = ts.createMap(); + ts.performance.mark("beforeProgram"); + var host = createProgramOptions.host || createCompilerHost(options); + var configParsingHost = parseConfigHostFromCompilerHostLike(host); + var skipDefaultLib = options.noLib; + var getDefaultLibraryFileName = ts.memoize(function () { return host.getDefaultLibFileName(options); }); + var defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : ts.getDirectoryPath(getDefaultLibraryFileName()); + var programDiagnostics = ts.createDiagnosticCollection(); + var currentDirectory = host.getCurrentDirectory(); + var supportedExtensions = ts.getSupportedExtensions(options); + var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions); + var hasEmitBlockingDiagnostics = ts.createMap(); + var _compilerOptionsObjectLiteralSyntax; + var moduleResolutionCache; + var resolveModuleNamesWorker; + var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse; + if (host.resolveModuleNames) { + resolveModuleNamesWorker = function (moduleNames, containingFile, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.assertEachDefined(moduleNames), containingFile, reusedNames, redirectedReference, options).map(function (resolved) { + if (!resolved || resolved.extension !== undefined) { + return resolved; + } + var withExtension = ts.clone(resolved); + withExtension.extension = ts.extensionFromPath(resolved.resolvedFileName); + return withExtension; + }); }; + } + else { + moduleResolutionCache = ts.createModuleResolutionCache(currentDirectory, function (x) { return host.getCanonicalFileName(x); }, options); + var loader_1 = function (moduleName, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule; }; + resolveModuleNamesWorker = function (moduleNames, containingFile, _reusedNames, redirectedReference) { return loadWithLocalCache(ts.Debug.assertEachDefined(moduleNames), containingFile, redirectedReference, loader_1); }; + } + var resolveTypeReferenceDirectiveNamesWorker; + if (host.resolveTypeReferenceDirectives) { + resolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference) { return host.resolveTypeReferenceDirectives(ts.Debug.assertEachDefined(typeDirectiveNames), containingFile, redirectedReference, options); }; + } + else { + var loader_2 = function (typesRef, containingFile, redirectedReference) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference).resolvedTypeReferenceDirective; }; + resolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference) { return loadWithLocalCache(ts.Debug.assertEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, loader_2); }; + } + var packageIdToSourceFile = ts.createMap(); + var sourceFileToPackageName = ts.createMap(); + var redirectTargetsMap = ts.createMultiMap(); + var filesByName = ts.createMap(); + var missingFilePaths; + var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createMap() : undefined; + var resolvedProjectReferences; + var projectReferenceRedirects; + var mapFromFileToProjectReferenceRedirects; + var mapFromToProjectReferenceRedirectSource; + var useSourceOfProjectReferenceRedirect = !!host.useSourceOfProjectReferenceRedirect && host.useSourceOfProjectReferenceRedirect(); + var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options); + var structuralIsReused; + structuralIsReused = tryReuseStructureFromOldProgram(); + if (structuralIsReused !== 2) { + processingDefaultLibFiles = []; + processingOtherFiles = []; + if (projectReferences) { + if (!resolvedProjectReferences) { + resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile); + } + if (host.setResolvedProjectReferenceCallbacks) { + host.setResolvedProjectReferenceCallbacks({ + getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect, + forEachResolvedProjectReference: forEachResolvedProjectReference + }); + } + if (rootNames.length) { + for (var _i = 0, resolvedProjectReferences_1 = resolvedProjectReferences; _i < resolvedProjectReferences_1.length; _i++) { + var parsedRef = resolvedProjectReferences_1[_i]; + if (!parsedRef) + continue; + var out = parsedRef.commandLine.options.outFile || parsedRef.commandLine.options.out; + if (useSourceOfProjectReferenceRedirect) { + if (out || ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { + for (var _a = 0, _b = parsedRef.commandLine.fileNames; _a < _b.length; _a++) { + var fileName = _b[_a]; + processSourceFile(fileName, false, false, undefined); + } + } + } + else { + if (out) { + processSourceFile(ts.changeExtension(out, ".d.ts"), false, false, undefined); + } + else if (ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { + for (var _c = 0, _d = parsedRef.commandLine.fileNames; _c < _d.length; _c++) { + var fileName = _d[_c]; + if (!ts.fileExtensionIs(fileName, ".d.ts") && !ts.fileExtensionIs(fileName, ".json")) { + processSourceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), false, false, undefined); + } + } + } + } + } + } + } + ts.forEach(rootNames, function (name) { return processRootFile(name, false, false); }); + var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray; + if (typeReferences.length) { + var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory(); + var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile); + var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename); + for (var i = 0; i < typeReferences.length; i++) { + processTypeReferenceDirective(typeReferences[i], resolutions[i]); + } + } + if (rootNames.length && !skipDefaultLib) { + var defaultLibraryFileName = getDefaultLibraryFileName(); + if (!options.lib && defaultLibraryFileName) { + processRootFile(defaultLibraryFileName, true, false); + } + else { + ts.forEach(options.lib, function (libFileName) { + processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), true, false); + }); + } + } + missingFilePaths = ts.arrayFrom(ts.mapDefinedIterator(filesByName.entries(), function (_a) { + var path = _a[0], file = _a[1]; + return file === undefined ? path : undefined; + })); + files = ts.stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles); + processingDefaultLibFiles = undefined; + processingOtherFiles = undefined; + } + ts.Debug.assert(!!missingFilePaths); + if (oldProgram && host.onReleaseOldSourceFile) { + var oldSourceFiles = oldProgram.getSourceFiles(); + for (var _e = 0, oldSourceFiles_1 = oldSourceFiles; _e < oldSourceFiles_1.length; _e++) { + var oldSourceFile = oldSourceFiles_1[_e]; + var newFile = getSourceFileByPath(oldSourceFile.resolvedPath); + if (shouldCreateNewSourceFile || !newFile || + (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) { + host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path)); + } + } + oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference, resolvedProjectReferencePath) { + if (resolvedProjectReference && !getResolvedProjectReferenceByPath(resolvedProjectReferencePath)) { + host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), false); + } + }); + } + oldProgram = undefined; + var program = { + getRootFileNames: function () { return rootNames; }, + getSourceFile: getSourceFile, + getSourceFileByPath: getSourceFileByPath, + getSourceFiles: function () { return files; }, + getMissingFilePaths: function () { return missingFilePaths; }, + getRefFileMap: function () { return refFileMap; }, + getFilesByNameMap: function () { return filesByName; }, + getCompilerOptions: function () { return options; }, + getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getSemanticDiagnostics: getSemanticDiagnostics, + getSuggestionDiagnostics: getSuggestionDiagnostics, + getDeclarationDiagnostics: getDeclarationDiagnostics, + getBindAndCheckDiagnostics: getBindAndCheckDiagnostics, + getProgramDiagnostics: getProgramDiagnostics, + getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, + getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, + getCommonSourceDirectory: getCommonSourceDirectory, + emit: emit, + getCurrentDirectory: function () { return currentDirectory; }, + getNodeCount: function () { return getDiagnosticsProducingTypeChecker().getNodeCount(); }, + getIdentifierCount: function () { return getDiagnosticsProducingTypeChecker().getIdentifierCount(); }, + getSymbolCount: function () { return getDiagnosticsProducingTypeChecker().getSymbolCount(); }, + getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); }, + getRelationCacheSizes: function () { return getDiagnosticsProducingTypeChecker().getRelationCacheSizes(); }, + getFileProcessingDiagnostics: function () { return fileProcessingDiagnostics; }, + getResolvedTypeReferenceDirectives: function () { return resolvedTypeReferenceDirectives; }, + isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary, + isSourceFileDefaultLibrary: isSourceFileDefaultLibrary, + dropDiagnosticsProducingTypeChecker: dropDiagnosticsProducingTypeChecker, + getSourceFileFromReference: getSourceFileFromReference, + getLibFileFromReference: getLibFileFromReference, + sourceFileToPackageName: sourceFileToPackageName, + redirectTargetsMap: redirectTargetsMap, + isEmittedFile: isEmittedFile, + getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics, + getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache, + getProjectReferences: getProjectReferences, + getResolvedProjectReferences: getResolvedProjectReferences, + getProjectReferenceRedirect: getProjectReferenceRedirect, + getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect, + getResolvedProjectReferenceByPath: getResolvedProjectReferenceByPath, + forEachResolvedProjectReference: forEachResolvedProjectReference, + isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect, + emitBuildInfo: emitBuildInfo, + getProbableSymlinks: getProbableSymlinks + }; + verifyCompilerOptions(); + ts.performance.mark("afterProgram"); + ts.performance.measure("Program", "beforeProgram", "afterProgram"); + return program; + function compareDefaultLibFiles(a, b) { + return ts.compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b)); + } + function getDefaultLibFilePriority(a) { + if (ts.containsPath(defaultLibraryPath, a.fileName, false)) { + var basename = ts.getBaseFileName(a.fileName); + if (basename === "lib.d.ts" || basename === "lib.es6.d.ts") + return 0; + var name = ts.removeSuffix(ts.removePrefix(basename, "lib."), ".d.ts"); + var index = ts.libs.indexOf(name); + if (index !== -1) + return index + 1; + } + return ts.libs.length + 2; + } + function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile) { + return moduleResolutionCache && ts.resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache); + } + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function getCommonSourceDirectory() { + if (commonSourceDirectory === undefined) { + var emittedFiles = ts.filter(files, function (file) { return ts.sourceFileMayBeEmitted(file, program); }); + if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) { + commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, currentDirectory); + } + else if (options.composite && options.configFilePath) { + commonSourceDirectory = ts.getDirectoryPath(ts.normalizeSlashes(options.configFilePath)); + checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory); + } + else { + commonSourceDirectory = computeCommonSourceDirectory(emittedFiles); + } + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) { + commonSourceDirectory += ts.directorySeparator; + } + } + return commonSourceDirectory; + } + function getClassifiableNames() { + if (!classifiableNames) { + getTypeChecker(); + classifiableNames = ts.createUnderscoreEscapedMap(); + for (var _i = 0, files_2 = files; _i < files_2.length; _i++) { + var sourceFile = files_2[_i]; + ts.copyEntries(sourceFile.classifiableNames, classifiableNames); + } + } + return classifiableNames; + } + function resolveModuleNamesReusingOldState(moduleNames, containingFile, file) { + if (structuralIsReused === 0 && !file.ambientModuleNames.length) { + return resolveModuleNamesWorker(moduleNames, containingFile, undefined, getResolvedProjectReferenceToRedirect(file.originalFileName)); + } + var oldSourceFile = oldProgram && oldProgram.getSourceFile(containingFile); + if (oldSourceFile !== file && file.resolvedModules) { + var result_8 = []; + for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) { + var moduleName = moduleNames_1[_i]; + var resolvedModule = file.resolvedModules.get(moduleName); + result_8.push(resolvedModule); + } + return result_8; + } + var unknownModuleNames; + var result; + var reusedNames; + var predictedToResolveToAmbientModuleMarker = {}; + for (var i = 0; i < moduleNames.length; i++) { + var moduleName = moduleNames[i]; + if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) { + var oldResolvedModule = oldSourceFile && oldSourceFile.resolvedModules.get(moduleName); + if (oldResolvedModule) { + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, ts.Diagnostics.Reusing_resolution_of_module_0_to_file_1_from_old_program, moduleName, containingFile); + } + (result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule; + (reusedNames || (reusedNames = [])).push(moduleName); + continue; + } + } + var resolvesToAmbientModuleInNonModifiedFile = false; + if (ts.contains(file.ambientModuleNames, moduleName)) { + resolvesToAmbientModuleInNonModifiedFile = true; + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName, containingFile); + } + } + else { + resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName); + } + if (resolvesToAmbientModuleInNonModifiedFile) { + (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker; + } + else { + (unknownModuleNames || (unknownModuleNames = [])).push(moduleName); + } + } + var resolutions = unknownModuleNames && unknownModuleNames.length + ? resolveModuleNamesWorker(unknownModuleNames, containingFile, reusedNames, getResolvedProjectReferenceToRedirect(file.originalFileName)) + : ts.emptyArray; + if (!result) { + ts.Debug.assert(resolutions.length === moduleNames.length); + return resolutions; + } + var j = 0; + for (var i = 0; i < result.length; i++) { + if (result[i]) { + if (result[i] === predictedToResolveToAmbientModuleMarker) { + result[i] = undefined; + } + } + else { + result[i] = resolutions[j]; + j++; + } + } + ts.Debug.assert(j === resolutions.length); + return result; + function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) { + var resolutionToFile = ts.getResolvedModule(oldSourceFile, moduleName); + var resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName); + if (resolutionToFile && resolvedFile) { + return false; + } + var unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName); + if (!unmodifiedFile) { + return false; + } + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName, unmodifiedFile); + } + return true; + } + } + function canReuseProjectReferences() { + return !forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, index, parent) { + var newRef = (parent ? parent.commandLine.projectReferences : projectReferences)[index]; + var newResolvedRef = parseProjectReferenceConfigFile(newRef); + if (oldResolvedRef) { + return !newResolvedRef || newResolvedRef.sourceFile !== oldResolvedRef.sourceFile; + } + else { + return newResolvedRef !== undefined; + } + }, function (oldProjectReferences, parent) { + var newReferences = parent ? getResolvedProjectReferenceByPath(parent.sourceFile.path).commandLine.projectReferences : projectReferences; + return !ts.arrayIsEqualTo(oldProjectReferences, newReferences, ts.projectReferenceIsEqualTo); + }); + } + function tryReuseStructureFromOldProgram() { + if (!oldProgram) { + return 0; + } + var oldOptions = oldProgram.getCompilerOptions(); + if (ts.changesAffectModuleResolution(oldOptions, options)) { + return oldProgram.structureIsReused = 0; + } + ts.Debug.assert(!(oldProgram.structureIsReused & (2 | 1))); + var oldRootNames = oldProgram.getRootFileNames(); + if (!ts.arrayIsEqualTo(oldRootNames, rootNames)) { + return oldProgram.structureIsReused = 0; + } + if (!ts.arrayIsEqualTo(options.types, oldOptions.types)) { + return oldProgram.structureIsReused = 0; + } + if (!canReuseProjectReferences()) { + return oldProgram.structureIsReused = 0; + } + if (projectReferences) { + resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile); + if (host.setResolvedProjectReferenceCallbacks) { + host.setResolvedProjectReferenceCallbacks({ + getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect, + forEachResolvedProjectReference: forEachResolvedProjectReference + }); + } + } + var newSourceFiles = []; + var modifiedSourceFiles = []; + oldProgram.structureIsReused = 2; + if (oldProgram.getMissingFilePaths().some(function (missingFilePath) { return host.fileExists(missingFilePath); })) { + return oldProgram.structureIsReused = 0; + } + var oldSourceFiles = oldProgram.getSourceFiles(); + var seenPackageNames = ts.createMap(); + for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) { + var oldSourceFile = oldSourceFiles_2[_i]; + var newSourceFile = host.getSourceFileByPath + ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, options.target, undefined, shouldCreateNewSourceFile) + : host.getSourceFile(oldSourceFile.fileName, options.target, undefined, shouldCreateNewSourceFile); + if (!newSourceFile) { + return oldProgram.structureIsReused = 0; + } + ts.Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`"); + var fileChanged = void 0; + if (oldSourceFile.redirectInfo) { + if (newSourceFile !== oldSourceFile.redirectInfo.unredirected) { + return oldProgram.structureIsReused = 0; + } + fileChanged = false; + newSourceFile = oldSourceFile; + } + else if (oldProgram.redirectTargetsMap.has(oldSourceFile.path)) { + if (newSourceFile !== oldSourceFile) { + return oldProgram.structureIsReused = 0; + } + fileChanged = false; + } + else { + fileChanged = newSourceFile !== oldSourceFile; + } + newSourceFile.path = oldSourceFile.path; + newSourceFile.originalFileName = oldSourceFile.originalFileName; + newSourceFile.resolvedPath = oldSourceFile.resolvedPath; + newSourceFile.fileName = oldSourceFile.fileName; + var packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path); + if (packageName !== undefined) { + var prevKind = seenPackageNames.get(packageName); + var newKind = fileChanged ? 1 : 0; + if ((prevKind !== undefined && newKind === 1) || prevKind === 1) { + return oldProgram.structureIsReused = 0; + } + seenPackageNames.set(packageName, newKind); + } + if (fileChanged) { + if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) { + return oldProgram.structureIsReused = 0; + } + if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) { + oldProgram.structureIsReused = 1; + } + if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) { + oldProgram.structureIsReused = 1; + } + collectExternalModuleReferences(newSourceFile); + if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) { + oldProgram.structureIsReused = 1; + } + if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) { + oldProgram.structureIsReused = 1; + } + if ((oldSourceFile.flags & 3145728) !== (newSourceFile.flags & 3145728)) { + oldProgram.structureIsReused = 1; + } + if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) { + oldProgram.structureIsReused = 1; + } + modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile }); + } + else if (hasInvalidatedResolution(oldSourceFile.path)) { + oldProgram.structureIsReused = 1; + modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile }); + } + newSourceFiles.push(newSourceFile); + } + if (oldProgram.structureIsReused !== 2) { + return oldProgram.structureIsReused; + } + var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; }); + for (var _a = 0, oldSourceFiles_3 = oldSourceFiles; _a < oldSourceFiles_3.length; _a++) { + var oldFile = oldSourceFiles_3[_a]; + if (!ts.contains(modifiedFiles, oldFile)) { + for (var _b = 0, _c = oldFile.ambientModuleNames; _b < _c.length; _b++) { + var moduleName = _c[_b]; + ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName); + } + } + } + for (var _d = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _d < modifiedSourceFiles_1.length; _d++) { + var _e = modifiedSourceFiles_1[_d], oldSourceFile = _e.oldFile, newSourceFile = _e.newFile; + var newSourceFilePath = ts.getNormalizedAbsolutePath(newSourceFile.originalFileName, currentDirectory); + var moduleNames = getModuleNames(newSourceFile); + var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFilePath, newSourceFile); + var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, ts.moduleResolutionIsEqualTo); + if (resolutionsChanged) { + oldProgram.structureIsReused = 1; + newSourceFile.resolvedModules = ts.zipToMap(moduleNames, resolutions); + } + else { + newSourceFile.resolvedModules = oldSourceFile.resolvedModules; + } + if (resolveTypeReferenceDirectiveNamesWorker) { + var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); }); + var resolutions_1 = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFilePath, getResolvedProjectReferenceToRedirect(newSourceFile.originalFileName)); + var resolutionsChanged_1 = ts.hasChangesInResolutions(typesReferenceDirectives, resolutions_1, oldSourceFile.resolvedTypeReferenceDirectiveNames, ts.typeDirectiveIsEqualTo); + if (resolutionsChanged_1) { + oldProgram.structureIsReused = 1; + newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToMap(typesReferenceDirectives, resolutions_1); + } + else { + newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames; + } + } + } + if (oldProgram.structureIsReused !== 2) { + return oldProgram.structureIsReused; + } + if (host.hasChangedAutomaticTypeDirectiveNames) { + return oldProgram.structureIsReused = 1; + } + missingFilePaths = oldProgram.getMissingFilePaths(); + refFileMap = oldProgram.getRefFileMap(); + ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length); + for (var _f = 0, newSourceFiles_1 = newSourceFiles; _f < newSourceFiles_1.length; _f++) { + var newSourceFile = newSourceFiles_1[_f]; + filesByName.set(newSourceFile.path, newSourceFile); + } + var oldFilesByNameMap = oldProgram.getFilesByNameMap(); + oldFilesByNameMap.forEach(function (oldFile, path) { + if (!oldFile) { + filesByName.set(path, oldFile); + return; + } + if (oldFile.path === path) { + if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) { + sourceFilesFoundSearchingNodeModules.set(oldFile.path, true); + } + return; + } + filesByName.set(path, filesByName.get(oldFile.path)); + }); + files = newSourceFiles; + fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics(); + for (var _g = 0, modifiedSourceFiles_2 = modifiedSourceFiles; _g < modifiedSourceFiles_2.length; _g++) { + var modifiedFile = modifiedSourceFiles_2[_g]; + fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile.newFile); + } + resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives(); + sourceFileToPackageName = oldProgram.sourceFileToPackageName; + redirectTargetsMap = oldProgram.redirectTargetsMap; + return oldProgram.structureIsReused = 2; + } + function getEmitHost(writeFileCallback) { + return __assign(__assign({ getPrependNodes: getPrependNodes, + getCanonicalFileName: getCanonicalFileName, getCommonSourceDirectory: program.getCommonSourceDirectory, getCompilerOptions: program.getCompilerOptions, getCurrentDirectory: function () { return currentDirectory; }, getNewLine: function () { return host.getNewLine(); }, getSourceFile: program.getSourceFile, getSourceFileByPath: program.getSourceFileByPath, getSourceFiles: program.getSourceFiles, getLibFileFromReference: program.getLibFileFromReference, isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary, + getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect, + isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect, + getProbableSymlinks: getProbableSymlinks, writeFile: writeFileCallback || (function (fileName, data, writeByteOrderMark, onError, sourceFiles) { return host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles); }), isEmitBlocked: isEmitBlocked, readFile: function (f) { return host.readFile(f); }, fileExists: function (f) { + var path = toPath(f); + if (getSourceFileByPath(path)) + return true; + if (ts.contains(missingFilePaths, path)) + return false; + return host.fileExists(f); + } }, (host.directoryExists ? { directoryExists: function (f) { return host.directoryExists(f); } } : {})), { useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, getProgramBuildInfo: function () { return program.getProgramBuildInfo && program.getProgramBuildInfo(); }, getSourceFileFromReference: function (file, ref) { return program.getSourceFileFromReference(file, ref); }, redirectTargetsMap: redirectTargetsMap }); + } + function emitBuildInfo(writeFileCallback) { + ts.Debug.assert(!options.out && !options.outFile); + ts.performance.mark("beforeEmit"); + var emitResult = ts.emitFiles(ts.notImplementedResolver, getEmitHost(writeFileCallback), undefined, ts.noTransformers, false, true); + ts.performance.mark("afterEmit"); + ts.performance.measure("Emit", "beforeEmit", "afterEmit"); + return emitResult; + } + function getResolvedProjectReferences() { + return resolvedProjectReferences; + } + function getProjectReferences() { + return projectReferences; + } + function getPrependNodes() { + return createPrependNodes(projectReferences, function (_ref, index) { return resolvedProjectReferences[index].commandLine; }, function (fileName) { + var path = toPath(fileName); + var sourceFile = getSourceFileByPath(path); + return sourceFile ? sourceFile.text : filesByName.has(path) ? undefined : host.readFile(path); + }); + } + function isSourceFileFromExternalLibrary(file) { + return !!sourceFilesFoundSearchingNodeModules.get(file.path); + } + function isSourceFileDefaultLibrary(file) { + if (file.hasNoDefaultLib) { + return true; + } + if (!options.noLib) { + return false; + } + var equalityComparer = host.useCaseSensitiveFileNames() ? ts.equateStringsCaseSensitive : ts.equateStringsCaseInsensitive; + if (!options.lib) { + return equalityComparer(file.fileName, getDefaultLibraryFileName()); + } + else { + return ts.some(options.lib, function (libFileName) { return equalityComparer(file.fileName, ts.combinePaths(defaultLibraryPath, libFileName)); }); + } + } + function getDiagnosticsProducingTypeChecker() { + return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = ts.createTypeChecker(program, true)); + } + function dropDiagnosticsProducingTypeChecker() { + diagnosticsProducingTypeChecker = undefined; + } + function getTypeChecker() { + return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, false)); + } + function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) { + return runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); }); + } + function isEmitBlocked(emitFileName) { + return hasEmitBlockingDiagnostics.has(toPath(emitFileName)); + } + function emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit) { + if (!forceDtsEmit) { + var result = handleNoEmitOptions(program, sourceFile, cancellationToken); + if (result) + return result; + } + var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile, cancellationToken); + ts.performance.mark("beforeEmit"); + var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile, ts.getTransformers(options, customTransformers, emitOnlyDtsFiles), emitOnlyDtsFiles, false, forceDtsEmit); + ts.performance.mark("afterEmit"); + ts.performance.measure("Emit", "beforeEmit", "afterEmit"); + return emitResult; + } + function getSourceFile(fileName) { + return getSourceFileByPath(toPath(fileName)); + } + function getSourceFileByPath(path) { + return filesByName.get(path) || undefined; + } + function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) { + if (sourceFile) { + return getDiagnostics(sourceFile, cancellationToken); + } + return ts.sortAndDeduplicateDiagnostics(ts.flatMap(program.getSourceFiles(), function (sourceFile) { + if (cancellationToken) { + cancellationToken.throwIfCancellationRequested(); + } + return getDiagnostics(sourceFile, cancellationToken); + })); + } + function getSyntacticDiagnostics(sourceFile, cancellationToken) { + return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken); + } + function getSemanticDiagnostics(sourceFile, cancellationToken) { + return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken); + } + function getBindAndCheckDiagnostics(sourceFile, cancellationToken) { + return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken); + } + function getProgramDiagnostics(sourceFile) { + if (ts.skipTypeChecking(sourceFile, options, program)) { + return ts.emptyArray; + } + var fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName); + var programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); + var diagnostics; + for (var _i = 0, _a = [fileProcessingDiagnosticsInFile, programDiagnosticsInFile]; _i < _a.length; _i++) { + var diags = _a[_i]; + if (diags) { + for (var _b = 0, diags_4 = diags; _b < diags_4.length; _b++) { + var diag = diags_4[_b]; + if (shouldReportDiagnostic(diag)) { + diagnostics = ts.append(diagnostics, diag); + } + } + } + } + return diagnostics || ts.emptyArray; + } + function getDeclarationDiagnostics(sourceFile, cancellationToken) { + var options = program.getCompilerOptions(); + if (!sourceFile || options.out || options.outFile) { + return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken); + } + else { + return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken); + } + } + function getSyntacticDiagnosticsForFile(sourceFile) { + if (ts.isSourceFileJS(sourceFile)) { + if (!sourceFile.additionalSyntacticDiagnostics) { + sourceFile.additionalSyntacticDiagnostics = getJSSyntacticDiagnosticsForFile(sourceFile); + } + return ts.concatenate(sourceFile.additionalSyntacticDiagnostics, sourceFile.parseDiagnostics); + } + return sourceFile.parseDiagnostics; + } + function runWithCancellationToken(func) { + try { + return func(); + } + catch (e) { + if (e instanceof ts.OperationCanceledException) { + noDiagnosticsTypeChecker = undefined; + diagnosticsProducingTypeChecker = undefined; + } + throw e; + } + } + function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) { + return ts.concatenate(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), getProgramDiagnostics(sourceFile)); + } + function getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken) { + return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedBindAndCheckDiagnosticsForFile, getBindAndCheckDiagnosticsForFileNoCache); + } + function getBindAndCheckDiagnosticsForFileNoCache(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + if (ts.skipTypeChecking(sourceFile, options, program)) { + return ts.emptyArray; + } + var typeChecker = getDiagnosticsProducingTypeChecker(); + ts.Debug.assert(!!sourceFile.bindDiagnostics); + var isCheckJs = ts.isCheckJsEnabledForFile(sourceFile, options); + var isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false; + var includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 || sourceFile.scriptKind === 4 || + sourceFile.scriptKind === 5 || isCheckJs || sourceFile.scriptKind === 7); + var bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : ts.emptyArray; + var checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : ts.emptyArray; + var diagnostics; + for (var _i = 0, _a = [bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined]; _i < _a.length; _i++) { + var diags = _a[_i]; + if (diags) { + for (var _b = 0, diags_5 = diags; _b < diags_5.length; _b++) { + var diag = diags_5[_b]; + if (shouldReportDiagnostic(diag)) { + diagnostics = ts.append(diagnostics, diag); + } + } + } + } + return diagnostics || ts.emptyArray; + }); + } + function getSuggestionDiagnostics(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + return getDiagnosticsProducingTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken); + }); + } + function shouldReportDiagnostic(diagnostic) { + var file = diagnostic.file, start = diagnostic.start; + if (file) { + var lineStarts = ts.getLineStarts(file); + var line = ts.computeLineAndCharacterOfPosition(lineStarts, start).line; + while (line > 0) { + var previousLineText = file.text.slice(lineStarts[line - 1], lineStarts[line]); + var result = ignoreDiagnosticCommentRegEx.exec(previousLineText); + if (!result) { + return true; + } + if (result[3]) { + return false; + } + line--; + } + } + return true; + } + function getJSSyntacticDiagnosticsForFile(sourceFile) { + return runWithCancellationToken(function () { + var diagnostics = []; + var parent = sourceFile; + walk(sourceFile); + return diagnostics; + function walk(node) { + switch (parent.kind) { + case 156: + case 159: + case 161: + if (parent.questionToken === node) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")); + return; + } + case 160: + case 162: + case 163: + case 164: + case 201: + case 244: + case 202: + case 242: + if (parent.type === node) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files)); + return; + } + } + switch (node.kind) { + case 255: + if (node.isTypeOnly) { + diagnostics.push(createDiagnosticForNode(node.parent, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type")); + return; + } + break; + case 260: + if (node.isTypeOnly) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "export type")); + return; + } + break; + case 253: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files)); + return; + case 259: + if (node.isExportEquals) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_TypeScript_files)); + return; + } + break; + case 279: + var heritageClause = node; + if (heritageClause.token === 113) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_TypeScript_files)); + return; + } + break; + case 246: + var interfaceKeyword = ts.tokenToString(114); + ts.Debug.assertDefined(interfaceKeyword); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, interfaceKeyword)); + return; + case 249: + var moduleKeyword = node.flags & 16 ? ts.tokenToString(136) : ts.tokenToString(135); + ts.Debug.assertDefined(moduleKeyword); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, moduleKeyword)); + return; + case 247: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files)); + return; + case 248: + var enumKeyword = ts.Debug.assertDefined(ts.tokenToString(88)); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, enumKeyword)); + return; + case 218: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files)); + return; + case 217: + diagnostics.push(createDiagnosticForNode(node.type, ts.Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files)); + return; + case 199: + ts.Debug.fail(); + } + var prevParent = parent; + parent = node; + ts.forEachChild(node, walk, walkArray); + parent = prevParent; + } + function walkArray(nodes) { + if (parent.decorators === nodes && !options.experimentalDecorators) { + diagnostics.push(createDiagnosticForNode(parent, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning)); + } + switch (parent.kind) { + case 245: + case 214: + case 161: + case 162: + case 163: + case 164: + case 201: + case 244: + case 202: + if (nodes === parent.typeParameters) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)); + return; + } + case 225: + if (nodes === parent.modifiers) { + return checkModifiers(parent.modifiers, parent.kind === 225); + } + break; + case 159: + if (nodes === parent.modifiers) { + for (var _i = 0, _a = nodes; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (modifier.kind !== 120) { + diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind))); + } + } + return; + } + break; + case 156: + if (nodes === parent.modifiers) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files)); + return; + } + break; + case 196: + case 197: + case 216: + case 267: + case 268: + case 198: + if (nodes === parent.typeArguments) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files)); + return; + } + break; + } + for (var _b = 0, nodes_6 = nodes; _b < nodes_6.length; _b++) { + var node = nodes_6[_b]; + walk(node); + } + } + function checkModifiers(modifiers, isConstValid) { + for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) { + var modifier = modifiers_1[_i]; + switch (modifier.kind) { + case 81: + if (isConstValid) { + continue; + } + case 119: + case 117: + case 118: + case 138: + case 130: + case 122: + diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind))); + break; + case 120: + case 89: + case 84: + } + } + } + function createDiagnosticForNodeArray(nodes, message, arg0, arg1, arg2) { + var start = nodes.pos; + return ts.createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2); + } + function createDiagnosticForNode(node, message, arg0, arg1, arg2) { + return ts.createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2); + } + }); + } + function getDeclarationDiagnosticsWorker(sourceFile, cancellationToken) { + return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedDeclarationDiagnosticsForFile, getDeclarationDiagnosticsForFileNoCache); + } + function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken); + return ts.getDeclarationDiagnostics(getEmitHost(ts.noop), resolver, sourceFile) || ts.emptyArray; + }); + } + function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics) { + var cachedResult = sourceFile + ? cache.perFile && cache.perFile.get(sourceFile.path) + : cache.allDiagnostics; + if (cachedResult) { + return cachedResult; + } + var result = getDiagnostics(sourceFile, cancellationToken); + if (sourceFile) { + if (!cache.perFile) { + cache.perFile = ts.createMap(); + } + cache.perFile.set(sourceFile.path, result); + } + else { + cache.allDiagnostics = result; + } + return result; + } + function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) { + return sourceFile.isDeclarationFile ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken); + } + function getOptionsDiagnostics() { + return ts.sortAndDeduplicateDiagnostics(ts.concatenate(fileProcessingDiagnostics.getGlobalDiagnostics(), ts.concatenate(programDiagnostics.getGlobalDiagnostics(), getOptionsDiagnosticsOfConfigFile()))); + } + function getOptionsDiagnosticsOfConfigFile() { + if (!options.configFile) { + return ts.emptyArray; + } + var diagnostics = programDiagnostics.getDiagnostics(options.configFile.fileName); + forEachResolvedProjectReference(function (resolvedRef) { + if (resolvedRef) { + diagnostics = ts.concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName)); + } + }); + return diagnostics; + } + function getGlobalDiagnostics() { + return rootNames.length ? ts.sortAndDeduplicateDiagnostics(getDiagnosticsProducingTypeChecker().getGlobalDiagnostics().slice()) : ts.emptyArray; + } + function getConfigFileParsingDiagnostics() { + return configFileParsingDiagnostics || ts.emptyArray; + } + function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib) { + processSourceFile(ts.normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, undefined); + } + function fileReferenceIsEqualTo(a, b) { + return a.fileName === b.fileName; + } + function moduleNameIsEqualTo(a, b) { + return a.kind === 75 + ? b.kind === 75 && a.escapedText === b.escapedText + : b.kind === 10 && a.text === b.text; + } + function collectExternalModuleReferences(file) { + if (file.imports) { + return; + } + var isJavaScriptFile = ts.isSourceFileJS(file); + var isExternalModuleFile = ts.isExternalModule(file); + var imports; + var moduleAugmentations; + var ambientModules; + if (options.importHelpers + && (options.isolatedModules || isExternalModuleFile) + && !file.isDeclarationFile) { + var externalHelpersModuleReference = ts.createLiteral(ts.externalHelpersModuleNameText); + var importDecl = ts.createImportDeclaration(undefined, undefined, undefined, externalHelpersModuleReference); + ts.addEmitFlags(importDecl, 67108864); + externalHelpersModuleReference.parent = importDecl; + importDecl.parent = file; + imports = [externalHelpersModuleReference]; + } + for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { + var node = _a[_i]; + collectModuleReferences(node, false); + } + if ((file.flags & 1048576) || isJavaScriptFile) { + collectDynamicImportOrRequireCalls(file); + } + file.imports = imports || ts.emptyArray; + file.moduleAugmentations = moduleAugmentations || ts.emptyArray; + file.ambientModuleNames = ambientModules || ts.emptyArray; + return; + function collectModuleReferences(node, inAmbientModule) { + if (ts.isAnyImportOrReExport(node)) { + var moduleNameExpr = ts.getExternalModuleName(node); + if (moduleNameExpr && ts.isStringLiteral(moduleNameExpr) && moduleNameExpr.text && (!inAmbientModule || !ts.isExternalModuleNameRelative(moduleNameExpr.text))) { + imports = ts.append(imports, moduleNameExpr); + } + } + else if (ts.isModuleDeclaration(node)) { + if (ts.isAmbientModule(node) && (inAmbientModule || ts.hasModifier(node, 2) || file.isDeclarationFile)) { + var nameText = ts.getTextOfIdentifierOrLiteral(node.name); + if (isExternalModuleFile || (inAmbientModule && !ts.isExternalModuleNameRelative(nameText))) { + (moduleAugmentations || (moduleAugmentations = [])).push(node.name); + } + else if (!inAmbientModule) { + if (file.isDeclarationFile) { + (ambientModules || (ambientModules = [])).push(nameText); + } + var body = node.body; + if (body) { + for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + collectModuleReferences(statement, true); + } + } + } + } + } + } + function collectDynamicImportOrRequireCalls(file) { + var r = /import|require/g; + while (r.exec(file.text) !== null) { + var node = getNodeAtPosition(file, r.lastIndex); + if (ts.isRequireCall(node, true)) { + imports = ts.append(imports, node.arguments[0]); + } + else if (ts.isImportCall(node) && node.arguments.length === 1 && ts.isStringLiteralLike(node.arguments[0])) { + imports = ts.append(imports, node.arguments[0]); + } + else if (ts.isLiteralImportTypeNode(node)) { + imports = ts.append(imports, node.argument.literal); + } + } + } + function getNodeAtPosition(sourceFile, position) { + var current = sourceFile; + var getContainingChild = function (child) { + if (child.pos <= position && (position < child.end || (position === child.end && (child.kind === 1)))) { + return child; + } + }; + while (true) { + var child = isJavaScriptFile && ts.hasJSDocNodes(current) && ts.forEach(current.jsDoc, getContainingChild) || ts.forEachChild(current, getContainingChild); + if (!child) { + return current; + } + current = child; + } + } + } + function getLibFileFromReference(ref) { + var libName = ts.toFileNameLowerCase(ref.fileName); + var libFileName = ts.libMap.get(libName); + if (libFileName) { + return getSourceFile(ts.combinePaths(defaultLibraryPath, libFileName)); + } + } + function getSourceFileFromReference(referencingFile, ref) { + return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), function (fileName) { return filesByName.get(toPath(fileName)) || undefined; }); + } + function getSourceFileFromReferenceWorker(fileName, getSourceFile, fail, refFile) { + if (ts.hasExtension(fileName)) { + var canonicalFileName_1 = host.getCanonicalFileName(fileName); + if (!options.allowNonTsExtensions && !ts.forEach(supportedExtensionsWithJsonIfResolveJsonModule, function (extension) { return ts.fileExtensionIs(canonicalFileName_1, extension); })) { + if (fail) { + if (ts.hasJSFileExtension(canonicalFileName_1)) { + fail(ts.Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName); + } + else { + fail(ts.Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + supportedExtensions.join("', '") + "'"); + } + } + return undefined; + } + var sourceFile = getSourceFile(fileName); + if (fail) { + if (!sourceFile) { + var redirect = getProjectReferenceRedirect(fileName); + if (redirect) { + fail(ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, fileName); + } + else { + fail(ts.Diagnostics.File_0_not_found, fileName); + } + } + else if (refFile && canonicalFileName_1 === host.getCanonicalFileName(refFile.fileName)) { + fail(ts.Diagnostics.A_file_cannot_have_a_reference_to_itself); + } + } + return sourceFile; + } + else { + var sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile(fileName); + if (sourceFileNoExtension) + return sourceFileNoExtension; + if (fail && options.allowNonTsExtensions) { + fail(ts.Diagnostics.File_0_not_found, fileName); + return undefined; + } + var sourceFileWithAddedExtension = ts.forEach(supportedExtensions, function (extension) { return getSourceFile(fileName + extension); }); + if (fail && !sourceFileWithAddedExtension) + fail(ts.Diagnostics.File_0_not_found, fileName + ".ts"); + return sourceFileWithAddedExtension; + } + } + function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, refFile) { + getSourceFileFromReferenceWorker(fileName, function (fileName) { return findSourceFile(fileName, toPath(fileName), isDefaultLib, ignoreNoDefaultLib, refFile, packageId); }, function (diagnostic) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return fileProcessingDiagnostics.add(createRefFileDiagnostic.apply(void 0, __spreadArrays([refFile, diagnostic], args))); + }, refFile && refFile.file); + } + function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, refFile) { + var refs = !refFile ? refFileMap && refFileMap.get(existingFile.path) : undefined; + var refToReportErrorOn = refs && ts.find(refs, function (ref) { return ref.referencedFileName === existingFile.fileName; }); + fileProcessingDiagnostics.add(refToReportErrorOn ? + createFileDiagnosticAtReference(refToReportErrorOn, ts.Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, existingFile.fileName, fileName) : + createRefFileDiagnostic(refFile, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, existingFile.fileName)); + } + function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName) { + var redirect = Object.create(redirectTarget); + redirect.fileName = fileName; + redirect.path = path; + redirect.resolvedPath = resolvedPath; + redirect.originalFileName = originalFileName; + redirect.redirectInfo = { redirectTarget: redirectTarget, unredirected: unredirected }; + sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0); + Object.defineProperties(redirect, { + id: { + get: function () { return this.redirectInfo.redirectTarget.id; }, + set: function (value) { this.redirectInfo.redirectTarget.id = value; }, + }, + symbol: { + get: function () { return this.redirectInfo.redirectTarget.symbol; }, + set: function (value) { this.redirectInfo.redirectTarget.symbol = value; }, + }, + }); + return redirect; + } + function findSourceFile(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId) { + if (useSourceOfProjectReferenceRedirect) { + var source = getSourceOfProjectReferenceRedirect(fileName); + if (!source && + host.realpath && + options.preserveSymlinks && + ts.isDeclarationFileName(fileName) && + ts.stringContains(fileName, ts.nodeModulesPathPart)) { + var realPath = host.realpath(fileName); + if (realPath !== fileName) + source = getSourceOfProjectReferenceRedirect(realPath); + } + if (source) { + var file_1 = ts.isString(source) ? + findSourceFile(source, toPath(source), isDefaultLib, ignoreNoDefaultLib, refFile, packageId) : + undefined; + if (file_1) + addFileToFilesByName(file_1, path, undefined); + return file_1; + } + } + var originalFileName = fileName; + if (filesByName.has(path)) { + var file_2 = filesByName.get(path); + addFileToRefFileMap(fileName, file_2 || undefined, refFile); + if (file_2 && options.forceConsistentCasingInFileNames) { + var checkedName = file_2.fileName; + var isRedirect = toPath(checkedName) !== toPath(fileName); + if (isRedirect) { + fileName = getProjectReferenceRedirect(fileName) || fileName; + } + var checkedAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory); + var inputAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory); + if (checkedAbsolutePath !== inputAbsolutePath) { + reportFileNamesDifferOnlyInCasingError(fileName, file_2, refFile); + } + } + if (file_2 && sourceFilesFoundSearchingNodeModules.get(file_2.path) && currentNodeModulesDepth === 0) { + sourceFilesFoundSearchingNodeModules.set(file_2.path, false); + if (!options.noResolve) { + processReferencedFiles(file_2, isDefaultLib); + processTypeReferenceDirectives(file_2); + } + if (!options.noLib) { + processLibReferenceDirectives(file_2); + } + modulesWithElidedImports.set(file_2.path, false); + processImportedModules(file_2); + } + else if (file_2 && modulesWithElidedImports.get(file_2.path)) { + if (currentNodeModulesDepth < maxNodeModuleJsDepth) { + modulesWithElidedImports.set(file_2.path, false); + processImportedModules(file_2); + } + } + return file_2 || undefined; + } + var redirectedPath; + if (refFile && !useSourceOfProjectReferenceRedirect) { + var redirectProject = getProjectReferenceRedirectProject(fileName); + if (redirectProject) { + if (redirectProject.commandLine.options.outFile || redirectProject.commandLine.options.out) { + return undefined; + } + var redirect = getProjectReferenceOutputName(redirectProject, fileName); + fileName = redirect; + redirectedPath = toPath(redirect); + } + } + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { return fileProcessingDiagnostics.add(createRefFileDiagnostic(refFile, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); }, shouldCreateNewSourceFile); + if (packageId) { + var packageIdKey = ts.packageIdToString(packageId); + var fileFromPackageId = packageIdToSourceFile.get(packageIdKey); + if (fileFromPackageId) { + var dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath(fileName), originalFileName); + redirectTargetsMap.add(fileFromPackageId.path, fileName); + addFileToFilesByName(dupFile, path, redirectedPath); + sourceFileToPackageName.set(path, packageId.name); + processingOtherFiles.push(dupFile); + return dupFile; + } + else if (file) { + packageIdToSourceFile.set(packageIdKey, file); + sourceFileToPackageName.set(path, packageId.name); + } + } + addFileToFilesByName(file, path, redirectedPath); + if (file) { + sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0); + file.fileName = fileName; + file.path = path; + file.resolvedPath = toPath(fileName); + file.originalFileName = originalFileName; + addFileToRefFileMap(fileName, file, refFile); + if (host.useCaseSensitiveFileNames()) { + var pathLowerCase = ts.toFileNameLowerCase(path); + var existingFile = filesByNameIgnoreCase.get(pathLowerCase); + if (existingFile) { + reportFileNamesDifferOnlyInCasingError(fileName, existingFile, refFile); + } + else { + filesByNameIgnoreCase.set(pathLowerCase, file); + } + } + skipDefaultLib = skipDefaultLib || (file.hasNoDefaultLib && !ignoreNoDefaultLib); + if (!options.noResolve) { + processReferencedFiles(file, isDefaultLib); + processTypeReferenceDirectives(file); + } + if (!options.noLib) { + processLibReferenceDirectives(file); + } + processImportedModules(file); + if (isDefaultLib) { + processingDefaultLibFiles.push(file); + } + else { + processingOtherFiles.push(file); + } + } + return file; + } + function addFileToRefFileMap(referencedFileName, file, refFile) { + if (refFile && file) { + (refFileMap || (refFileMap = ts.createMultiMap())).add(file.path, { + referencedFileName: referencedFileName, + kind: refFile.kind, + index: refFile.index, + file: refFile.file.path + }); + } + } + function addFileToFilesByName(file, path, redirectedPath) { + if (redirectedPath) { + filesByName.set(redirectedPath, file); + filesByName.set(path, file || false); + } + else { + filesByName.set(path, file); + } + } + function getProjectReferenceRedirect(fileName) { + var referencedProject = getProjectReferenceRedirectProject(fileName); + return referencedProject && getProjectReferenceOutputName(referencedProject, fileName); + } + function getProjectReferenceRedirectProject(fileName) { + if (!resolvedProjectReferences || !resolvedProjectReferences.length || ts.fileExtensionIs(fileName, ".d.ts") || ts.fileExtensionIs(fileName, ".json")) { + return undefined; + } + return getResolvedProjectReferenceToRedirect(fileName); + } + function getProjectReferenceOutputName(referencedProject, fileName) { + var out = referencedProject.commandLine.options.outFile || referencedProject.commandLine.options.out; + return out ? + ts.changeExtension(out, ".d.ts") : + ts.getOutputDeclarationFileName(fileName, referencedProject.commandLine, !host.useCaseSensitiveFileNames()); + } + function getResolvedProjectReferenceToRedirect(fileName) { + if (mapFromFileToProjectReferenceRedirects === undefined) { + mapFromFileToProjectReferenceRedirects = ts.createMap(); + forEachResolvedProjectReference(function (referencedProject, referenceProjectPath) { + if (referencedProject && + toPath(options.configFilePath) !== referenceProjectPath) { + referencedProject.commandLine.fileNames.forEach(function (f) { + return mapFromFileToProjectReferenceRedirects.set(toPath(f), referenceProjectPath); + }); + } + }); + } + var referencedProjectPath = mapFromFileToProjectReferenceRedirects.get(toPath(fileName)); + return referencedProjectPath && getResolvedProjectReferenceByPath(referencedProjectPath); + } + function forEachResolvedProjectReference(cb) { + return forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, index, parent) { + var ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index]; + var resolvedRefPath = toPath(resolveProjectReferencePath(ref)); + return cb(resolvedRef, resolvedRefPath); + }); + } + function getSourceOfProjectReferenceRedirect(file) { + if (!ts.isDeclarationFileName(file)) + return undefined; + if (mapFromToProjectReferenceRedirectSource === undefined) { + mapFromToProjectReferenceRedirectSource = ts.createMap(); + forEachResolvedProjectReference(function (resolvedRef) { + if (resolvedRef) { + var out = resolvedRef.commandLine.options.outFile || resolvedRef.commandLine.options.out; + if (out) { + var outputDts = ts.changeExtension(out, ".d.ts"); + mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), true); + } + else { + ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) { + if (!ts.fileExtensionIs(fileName, ".d.ts") && !ts.fileExtensionIs(fileName, ".json")) { + var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, host.useCaseSensitiveFileNames()); + mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName); + } + }); + } + } + }); + } + return mapFromToProjectReferenceRedirectSource.get(toPath(file)); + } + function isSourceOfProjectReferenceRedirect(fileName) { + return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName); + } + function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) { + var seenResolvedRefs; + return worker(projectReferences, resolvedProjectReferences, undefined, cbResolvedRef, cbRef); + function worker(projectReferences, resolvedProjectReferences, parent, cbResolvedRef, cbRef) { + if (cbRef) { + var result = cbRef(projectReferences, parent); + if (result) { + return result; + } + } + return ts.forEach(resolvedProjectReferences, function (resolvedRef, index) { + if (ts.contains(seenResolvedRefs, resolvedRef)) { + return undefined; + } + var result = cbResolvedRef(resolvedRef, index, parent); + if (result) { + return result; + } + if (!resolvedRef) + return undefined; + (seenResolvedRefs || (seenResolvedRefs = [])).push(resolvedRef); + return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef, cbResolvedRef, cbRef); + }); + } + } + function getResolvedProjectReferenceByPath(projectReferencePath) { + if (!projectReferenceRedirects) { + return undefined; + } + return projectReferenceRedirects.get(projectReferencePath) || undefined; + } + function processReferencedFiles(file, isDefaultLib) { + ts.forEach(file.referencedFiles, function (ref, index) { + var referencedFileName = resolveTripleslashReference(ref.fileName, file.originalFileName); + processSourceFile(referencedFileName, isDefaultLib, false, undefined, { + kind: ts.RefFileKind.ReferenceFile, + index: index, + file: file, + pos: ref.pos, + end: ref.end + }); + }); + } + function processTypeReferenceDirectives(file) { + var typeDirectives = ts.map(file.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); }); + if (!typeDirectives) { + return; + } + var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file.originalFileName, getResolvedProjectReferenceToRedirect(file.originalFileName)); + for (var i = 0; i < typeDirectives.length; i++) { + var ref = file.typeReferenceDirectives[i]; + var resolvedTypeReferenceDirective = resolutions[i]; + var fileName = ts.toFileNameLowerCase(ref.fileName); + ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective); + processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, { + kind: ts.RefFileKind.TypeReferenceDirective, + index: i, + file: file, + pos: ref.pos, + end: ref.end + }); + } + } + function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, refFile) { + var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective); + if (previousResolution && previousResolution.primary) { + return; + } + var saveResolution = true; + if (resolvedTypeReferenceDirective) { + if (resolvedTypeReferenceDirective.isExternalLibraryImport) + currentNodeModulesDepth++; + if (resolvedTypeReferenceDirective.primary) { + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, refFile); + } + else { + if (previousResolution) { + if (resolvedTypeReferenceDirective.resolvedFileName !== previousResolution.resolvedFileName) { + var otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName); + var existingFile_1 = getSourceFile(previousResolution.resolvedFileName); + if (otherFileText !== existingFile_1.text) { + var refs = !refFile ? refFileMap && refFileMap.get(existingFile_1.path) : undefined; + var refToReportErrorOn = refs && ts.find(refs, function (ref) { return ref.referencedFileName === existingFile_1.fileName; }); + fileProcessingDiagnostics.add(refToReportErrorOn ? + createFileDiagnosticAtReference(refToReportErrorOn, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName) : + createRefFileDiagnostic(refFile, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName)); + } + } + saveResolution = false; + } + else { + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, refFile); + } + } + if (resolvedTypeReferenceDirective.isExternalLibraryImport) + currentNodeModulesDepth--; + } + else { + fileProcessingDiagnostics.add(createRefFileDiagnostic(refFile, ts.Diagnostics.Cannot_find_type_definition_file_for_0, typeReferenceDirective)); + } + if (saveResolution) { + resolvedTypeReferenceDirectives.set(typeReferenceDirective, resolvedTypeReferenceDirective); + } + } + function processLibReferenceDirectives(file) { + ts.forEach(file.libReferenceDirectives, function (libReference) { + var libName = ts.toFileNameLowerCase(libReference.fileName); + var libFileName = ts.libMap.get(libName); + if (libFileName) { + processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), true, true); + } + else { + var unqualifiedLibName = ts.removeSuffix(ts.removePrefix(libName, "lib."), ".d.ts"); + var suggestion = ts.getSpellingSuggestion(unqualifiedLibName, ts.libs, ts.identity); + var message = suggestion ? ts.Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : ts.Diagnostics.Cannot_find_lib_definition_for_0; + fileProcessingDiagnostics.add(ts.createFileDiagnostic(file, libReference.pos, libReference.end - libReference.pos, message, libName, suggestion)); + } + }); + } + function createRefFileDiagnostic(refFile, message) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + if (!refFile) { + return ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args)); + } + else { + return ts.createFileDiagnostic.apply(void 0, __spreadArrays([refFile.file, refFile.pos, refFile.end - refFile.pos, message], args)); + } + } + function getCanonicalFileName(fileName) { + return host.getCanonicalFileName(fileName); + } + function processImportedModules(file) { + collectExternalModuleReferences(file); + if (file.imports.length || file.moduleAugmentations.length) { + var moduleNames = getModuleNames(file); + var resolutions = resolveModuleNamesReusingOldState(moduleNames, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory), file); + ts.Debug.assert(resolutions.length === moduleNames.length); + for (var i = 0; i < moduleNames.length; i++) { + var resolution = resolutions[i]; + ts.setResolvedModule(file, moduleNames[i], resolution); + if (!resolution) { + continue; + } + var isFromNodeModulesSearch = resolution.isExternalLibraryImport; + var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.extension); + var isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile; + var resolvedFileName = resolution.resolvedFileName; + if (isFromNodeModulesSearch) { + currentNodeModulesDepth++; + } + var elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModuleJsDepth; + var shouldAddFile = resolvedFileName + && !getResolutionDiagnostic(options, resolution) + && !options.noResolve + && i < file.imports.length + && !elideImport + && !(isJsFile && !options.allowJs) + && (ts.isInJSFile(file.imports[i]) || !(file.imports[i].flags & 4194304)); + if (elideImport) { + modulesWithElidedImports.set(file.path, true); + } + else if (shouldAddFile) { + var path = toPath(resolvedFileName); + var pos = ts.skipTrivia(file.text, file.imports[i].pos); + findSourceFile(resolvedFileName, path, false, false, { + kind: ts.RefFileKind.Import, + index: i, + file: file, + pos: pos, + end: file.imports[i].end + }, resolution.packageId); + } + if (isFromNodeModulesSearch) { + currentNodeModulesDepth--; + } + } + } + else { + file.resolvedModules = undefined; + } + } + function computeCommonSourceDirectory(sourceFiles) { + var fileNames = ts.mapDefined(sourceFiles, function (file) { return file.isDeclarationFile ? undefined : file.fileName; }); + return computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName); + } + function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) { + var allFilesBelongToPath = true; + var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory)); + var rootPaths; + for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) { + var sourceFile = sourceFiles_2[_i]; + if (!sourceFile.isDeclarationFile) { + var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory)); + if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) { + if (!rootPaths) + rootPaths = ts.arrayToSet(rootNames, toPath); + addProgramDiagnosticAtRefPath(sourceFile, rootPaths, ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, sourceFile.fileName, rootDirectory); + allFilesBelongToPath = false; + } + } + } + return allFilesBelongToPath; + } + function parseProjectReferenceConfigFile(ref) { + if (!projectReferenceRedirects) { + projectReferenceRedirects = ts.createMap(); + } + var refPath = resolveProjectReferencePath(ref); + var sourceFilePath = toPath(refPath); + var fromCache = projectReferenceRedirects.get(sourceFilePath); + if (fromCache !== undefined) { + return fromCache || undefined; + } + var commandLine; + var sourceFile; + if (host.getParsedCommandLine) { + commandLine = host.getParsedCommandLine(refPath); + if (!commandLine) { + addFileToFilesByName(undefined, sourceFilePath, undefined); + projectReferenceRedirects.set(sourceFilePath, false); + return undefined; + } + sourceFile = ts.Debug.assertDefined(commandLine.options.configFile); + ts.Debug.assert(!sourceFile.path || sourceFile.path === sourceFilePath); + addFileToFilesByName(sourceFile, sourceFilePath, undefined); + } + else { + var basePath = ts.getNormalizedAbsolutePath(ts.getDirectoryPath(refPath), host.getCurrentDirectory()); + sourceFile = host.getSourceFile(refPath, 100); + addFileToFilesByName(sourceFile, sourceFilePath, undefined); + if (sourceFile === undefined) { + projectReferenceRedirects.set(sourceFilePath, false); + return undefined; + } + commandLine = ts.parseJsonSourceFileConfigFileContent(sourceFile, configParsingHost, basePath, undefined, refPath); + } + sourceFile.fileName = refPath; + sourceFile.path = sourceFilePath; + sourceFile.resolvedPath = sourceFilePath; + sourceFile.originalFileName = refPath; + var resolvedRef = { commandLine: commandLine, sourceFile: sourceFile }; + projectReferenceRedirects.set(sourceFilePath, resolvedRef); + if (commandLine.projectReferences) { + resolvedRef.references = commandLine.projectReferences.map(parseProjectReferenceConfigFile); + } + return resolvedRef; + } + function verifyCompilerOptions() { + if (options.strictPropertyInitialization && !ts.getStrictOptionValue(options, "strictNullChecks")) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks"); + } + if (options.isolatedModules) { + if (options.out) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules"); + } + if (options.outFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules"); + } + } + if (options.inlineSourceMap) { + if (options.sourceMap) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap"); + } + if (options.mapRoot) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap"); + } + } + if (options.paths && options.baseUrl === undefined) { + createDiagnosticForOptionName(ts.Diagnostics.Option_paths_cannot_be_used_without_specifying_baseUrl_option, "paths"); + } + if (options.composite) { + if (options.declaration === false) { + createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_declaration_emit, "declaration"); + } + if (options.incremental === false) { + createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration"); + } + } + if (options.tsBuildInfoFile) { + if (!ts.isIncrementalCompilation(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "tsBuildInfoFile", "incremental", "composite"); + } + } + else if (options.incremental && !options.outFile && !options.out && !options.configFilePath) { + programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified)); + } + if (!options.listFilesOnly && options.noEmit && ts.isIncrementalCompilation(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noEmit", options.incremental ? "incremental" : "composite"); + } + verifyProjectReferences(); + if (options.composite) { + var rootPaths = ts.arrayToSet(rootNames, toPath); + for (var _i = 0, files_3 = files; _i < files_3.length; _i++) { + var file = files_3[_i]; + if (ts.sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) { + addProgramDiagnosticAtRefPath(file, rootPaths, ts.Diagnostics.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern, file.fileName, options.configFilePath || ""); + } + } + } + if (options.paths) { + for (var key in options.paths) { + if (!ts.hasProperty(options.paths, key)) { + continue; + } + if (!ts.hasZeroOrOneAsteriskCharacter(key)) { + createDiagnosticForOptionPaths(true, key, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, key); + } + if (ts.isArray(options.paths[key])) { + var len = options.paths[key].length; + if (len === 0) { + createDiagnosticForOptionPaths(false, key, ts.Diagnostics.Substitutions_for_pattern_0_shouldn_t_be_an_empty_array, key); + } + for (var i = 0; i < len; i++) { + var subst = options.paths[key][i]; + var typeOfSubst = typeof subst; + if (typeOfSubst === "string") { + if (!ts.hasZeroOrOneAsteriskCharacter(subst)) { + createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, subst, key); + } + } + else { + createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst); + } + } + } + else { + createDiagnosticForOptionPaths(false, key, ts.Diagnostics.Substitutions_for_pattern_0_should_be_an_array, key); + } + } + } + if (!options.sourceMap && !options.inlineSourceMap) { + if (options.inlineSources) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources"); + } + if (options.sourceRoot) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot"); + } + } + if (options.out && options.outFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile"); + } + if (options.mapRoot && !(options.sourceMap || options.declarationMap)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "mapRoot", "sourceMap", "declarationMap"); + } + if (options.declarationDir) { + if (!ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite"); + } + if (options.out || options.outFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile"); + } + } + if (options.declarationMap && !ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationMap", "declaration", "composite"); + } + if (options.lib && options.noLib) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"); + } + if (options.noImplicitUseStrict && ts.getStrictOptionValue(options, "alwaysStrict")) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict"); + } + var languageVersion = options.target || 0; + var outFile = options.outFile || options.out; + var firstNonAmbientExternalModuleSourceFile = ts.find(files, function (f) { return ts.isExternalModule(f) && !f.isDeclarationFile; }); + if (options.isolatedModules) { + if (options.module === ts.ModuleKind.None && languageVersion < 2) { + createDiagnosticForOptionName(ts.Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher, "isolatedModules", "target"); + } + var firstNonExternalModuleSourceFile = ts.find(files, function (f) { return !ts.isExternalModule(f) && !ts.isSourceFileJS(f) && !f.isDeclarationFile && f.scriptKind !== 6; }); + if (firstNonExternalModuleSourceFile) { + var span = ts.getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile); + programDiagnostics.add(ts.createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.All_files_must_be_modules_when_the_isolatedModules_flag_is_provided)); + } + } + else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 && options.module === ts.ModuleKind.None) { + var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator); + programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none)); + } + if (outFile && !options.emitDeclarationOnly) { + if (options.module && !(options.module === ts.ModuleKind.AMD || options.module === ts.ModuleKind.System)) { + createDiagnosticForOptionName(ts.Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module"); + } + else if (options.module === undefined && firstNonAmbientExternalModuleSourceFile) { + var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator); + programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile")); + } + } + if (options.resolveJsonModule) { + if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs) { + createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule"); + } + else if (!ts.hasJsonModuleEmitEnabled(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext, "resolveJsonModule", "module"); + } + } + if (options.outDir || + options.sourceRoot || + options.mapRoot) { + var dir = getCommonSourceDirectory(); + if (options.outDir && dir === "" && files.some(function (file) { return ts.getRootLength(file.fileName) > 1; })) { + createDiagnosticForOptionName(ts.Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files, "outDir"); + } + } + if (options.useDefineForClassFields && languageVersion === 0) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields"); + } + if (options.checkJs && !options.allowJs) { + programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs")); + } + if (options.emitDeclarationOnly) { + if (!ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "emitDeclarationOnly", "declaration", "composite"); + } + if (options.noEmit) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationOnly", "noEmit"); + } + } + if (options.emitDecoratorMetadata && + !options.experimentalDecorators) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"); + } + if (options.jsxFactory) { + if (options.reactNamespace) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory"); + } + if (!ts.parseIsolatedEntityName(options.jsxFactory, languageVersion)) { + createOptionValueDiagnostic("jsxFactory", ts.Diagnostics.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFactory); + } + } + else if (options.reactNamespace && !ts.isIdentifierText(options.reactNamespace, languageVersion)) { + createOptionValueDiagnostic("reactNamespace", ts.Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace); + } + if (!options.noEmit && !options.suppressOutputPathCheck) { + var emitHost = getEmitHost(); + var emitFilesSeen_1 = ts.createMap(); + ts.forEachEmittedFile(emitHost, function (emitFileNames) { + if (!options.emitDeclarationOnly) { + verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen_1); + } + verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen_1); + }); + } + function verifyEmitFilePath(emitFileName, emitFilesSeen) { + if (emitFileName) { + var emitFilePath = toPath(emitFileName); + if (filesByName.has(emitFilePath)) { + var chain = void 0; + if (!options.configFilePath) { + chain = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig); + } + chain = ts.chainDiagnosticMessages(chain, ts.Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file, emitFileName); + blockEmittingOfFile(emitFileName, ts.createCompilerDiagnosticFromMessageChain(chain)); + } + var emitFileKey = !host.useCaseSensitiveFileNames() ? ts.toFileNameLowerCase(emitFilePath) : emitFilePath; + if (emitFilesSeen.has(emitFileKey)) { + blockEmittingOfFile(emitFileName, ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, emitFileName)); + } + else { + emitFilesSeen.set(emitFileKey, true); + } + } + } + } + function createFileDiagnosticAtReference(refPathToReportErrorOn, message) { + var _a, _b; + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + var refFile = ts.Debug.assertDefined(getSourceFileByPath(refPathToReportErrorOn.file)); + var kind = refPathToReportErrorOn.kind, index = refPathToReportErrorOn.index; + var pos, end; + switch (kind) { + case ts.RefFileKind.Import: + pos = ts.skipTrivia(refFile.text, refFile.imports[index].pos); + end = refFile.imports[index].end; + break; + case ts.RefFileKind.ReferenceFile: + (_a = refFile.referencedFiles[index], pos = _a.pos, end = _a.end); + break; + case ts.RefFileKind.TypeReferenceDirective: + (_b = refFile.typeReferenceDirectives[index], pos = _b.pos, end = _b.end); + break; + default: + return ts.Debug.assertNever(kind); + } + return ts.createFileDiagnostic.apply(void 0, __spreadArrays([refFile, pos, end - pos, message], args)); + } + function addProgramDiagnosticAtRefPath(file, rootPaths, message) { + var args = []; + for (var _i = 3; _i < arguments.length; _i++) { + args[_i - 3] = arguments[_i]; + } + var refPaths = refFileMap && refFileMap.get(file.path); + var refPathToReportErrorOn = ts.forEach(refPaths, function (refPath) { return rootPaths.has(refPath.file) ? refPath : undefined; }) || + ts.elementAt(refPaths, 0); + programDiagnostics.add(refPathToReportErrorOn ? createFileDiagnosticAtReference.apply(void 0, __spreadArrays([refPathToReportErrorOn, message], args)) : ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args))); + } + function verifyProjectReferences() { + var buildInfoPath = !options.noEmit && !options.suppressOutputPathCheck ? ts.getTsBuildInfoEmitOutputFilePath(options) : undefined; + forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, index, parent) { + var ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index]; + var parentFile = parent && parent.sourceFile; + if (!resolvedRef) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.File_0_not_found, ref.path); + return; + } + var options = resolvedRef.commandLine.options; + if (!options.composite) { + var inputs = parent ? parent.commandLine.fileNames : rootNames; + if (inputs.length) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path); + } + } + if (ref.prepend) { + var out = options.outFile || options.out; + if (out) { + if (!host.fileExists(out)) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path); + } + } + else { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Cannot_prepend_project_0_because_it_does_not_have_outFile_set, ref.path); + } + } + if (!parent && buildInfoPath && buildInfoPath === ts.getTsBuildInfoEmitOutputFilePath(options)) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path); + hasEmitBlockingDiagnostics.set(toPath(buildInfoPath), true); + } + }); + } + function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) { + var needCompilerDiagnostic = true; + var pathsSyntax = getOptionPathsSyntax(); + for (var _i = 0, pathsSyntax_1 = pathsSyntax; _i < pathsSyntax_1.length; _i++) { + var pathProp = pathsSyntax_1[_i]; + if (ts.isObjectLiteralExpression(pathProp.initializer)) { + for (var _a = 0, _b = ts.getPropertyAssignment(pathProp.initializer, key); _a < _b.length; _a++) { + var keyProps = _b[_a]; + var initializer = keyProps.initializer; + if (ts.isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) { + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, arg0, arg1, arg2)); + needCompilerDiagnostic = false; + } + } + } + } + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1, arg2)); + } + } + function createDiagnosticForOptionPaths(onKey, key, message, arg0) { + var needCompilerDiagnostic = true; + var pathsSyntax = getOptionPathsSyntax(); + for (var _i = 0, pathsSyntax_2 = pathsSyntax; _i < pathsSyntax_2.length; _i++) { + var pathProp = pathsSyntax_2[_i]; + if (ts.isObjectLiteralExpression(pathProp.initializer) && + createOptionDiagnosticInObjectLiteralSyntax(pathProp.initializer, onKey, key, undefined, message, arg0)) { + needCompilerDiagnostic = false; + } + } + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0)); + } + } + function getOptionsSyntaxByName(name) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + if (compilerOptionsObjectLiteralSyntax) { + return ts.getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name); + } + return undefined; + } + function getOptionPathsSyntax() { + return getOptionsSyntaxByName("paths") || ts.emptyArray; + } + function createDiagnosticForOptionName(message, option1, option2, option3) { + createDiagnosticForOption(true, option1, option2, message, option1, option2, option3); + } + function createOptionValueDiagnostic(option1, message, arg0) { + createDiagnosticForOption(false, option1, undefined, message, arg0); + } + function createDiagnosticForReference(sourceFile, index, message, arg0, arg1) { + var referencesSyntax = ts.firstDefined(ts.getTsConfigPropArray(sourceFile || options.configFile, "references"), function (property) { return ts.isArrayLiteralExpression(property.initializer) ? property.initializer : undefined; }); + if (referencesSyntax && referencesSyntax.elements.length > index) { + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, arg0, arg1)); + } + else { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1)); + } + } + function createDiagnosticForOption(onKey, option1, option2, message, arg0, arg1, arg2) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + var needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || + !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2); + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1, arg2)); + } + } + function getCompilerOptionsObjectLiteralSyntax() { + if (_compilerOptionsObjectLiteralSyntax === undefined) { + _compilerOptionsObjectLiteralSyntax = null; + var jsonObjectLiteral = ts.getTsConfigObjectLiteralExpression(options.configFile); + if (jsonObjectLiteral) { + for (var _i = 0, _a = ts.getPropertyAssignment(jsonObjectLiteral, "compilerOptions"); _i < _a.length; _i++) { + var prop = _a[_i]; + if (ts.isObjectLiteralExpression(prop.initializer)) { + _compilerOptionsObjectLiteralSyntax = prop.initializer; + break; + } + } + } + } + return _compilerOptionsObjectLiteralSyntax; + } + function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2) { + var props = ts.getPropertyAssignment(objectLiteral, key1, key2); + for (var _i = 0, props_3 = props; _i < props_3.length; _i++) { + var prop = props_3[_i]; + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2)); + } + return !!props.length; + } + function blockEmittingOfFile(emitFileName, diag) { + hasEmitBlockingDiagnostics.set(toPath(emitFileName), true); + programDiagnostics.add(diag); + } + function isEmittedFile(file) { + if (options.noEmit) { + return false; + } + var filePath = toPath(file); + if (getSourceFileByPath(filePath)) { + return false; + } + var out = options.outFile || options.out; + if (out) { + return isSameFile(filePath, out) || isSameFile(filePath, ts.removeFileExtension(out) + ".d.ts"); + } + if (options.declarationDir && ts.containsPath(options.declarationDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames())) { + return true; + } + if (options.outDir) { + return ts.containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames()); + } + if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensions) || ts.fileExtensionIs(filePath, ".d.ts")) { + var filePathWithoutExtension = ts.removeFileExtension(filePath); + return !!getSourceFileByPath((filePathWithoutExtension + ".ts")) || + !!getSourceFileByPath((filePathWithoutExtension + ".tsx")); + } + return false; + } + function isSameFile(file1, file2) { + return ts.comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === 0; + } + function getProbableSymlinks() { + if (host.getSymlinks) { + return host.getSymlinks(); + } + return symlinks || (symlinks = ts.discoverProbableSymlinks(files, getCanonicalFileName, host.getCurrentDirectory())); + } + } + ts.createProgram = createProgram; + function handleNoEmitOptions(program, sourceFile, cancellationToken) { + var options = program.getCompilerOptions(); + if (options.noEmit) { + return { diagnostics: ts.emptyArray, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true }; + } + if (!options.noEmitOnError) + return undefined; + var diagnostics = __spreadArrays(program.getOptionsDiagnostics(cancellationToken), program.getSyntacticDiagnostics(sourceFile, cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSemanticDiagnostics(sourceFile, cancellationToken)); + if (diagnostics.length === 0 && ts.getEmitDeclarations(program.getCompilerOptions())) { + diagnostics = program.getDeclarationDiagnostics(undefined, cancellationToken); + } + return diagnostics.length > 0 ? + { diagnostics: diagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true } : + undefined; + } + ts.handleNoEmitOptions = handleNoEmitOptions; + function parseConfigHostFromCompilerHostLike(host, directoryStructureHost) { + if (directoryStructureHost === void 0) { directoryStructureHost = host; } + return { + fileExists: function (f) { return directoryStructureHost.fileExists(f); }, + readDirectory: function (root, extensions, excludes, includes, depth) { + ts.Debug.assertDefined(directoryStructureHost.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'"); + return directoryStructureHost.readDirectory(root, extensions, excludes, includes, depth); + }, + readFile: function (f) { return directoryStructureHost.readFile(f); }, + useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(), + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + onUnRecoverableConfigFileDiagnostic: host.onUnRecoverableConfigFileDiagnostic || ts.returnUndefined, + trace: host.trace ? function (s) { return host.trace(s); } : undefined + }; + } + ts.parseConfigHostFromCompilerHostLike = parseConfigHostFromCompilerHostLike; + function createPrependNodes(projectReferences, getCommandLine, readFile) { + if (!projectReferences) + return ts.emptyArray; + var nodes; + for (var i = 0; i < projectReferences.length; i++) { + var ref = projectReferences[i]; + var resolvedRefOpts = getCommandLine(ref, i); + if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) { + var out = resolvedRefOpts.options.outFile || resolvedRefOpts.options.out; + if (!out) + continue; + var _a = ts.getOutputPathsForBundle(resolvedRefOpts.options, true), jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + var node = ts.createInputFiles(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath); + (nodes || (nodes = [])).push(node); + } + } + return nodes || ts.emptyArray; + } + ts.createPrependNodes = createPrependNodes; + function resolveProjectReferencePath(hostOrRef, ref) { + var passedInRef = ref ? ref : hostOrRef; + return ts.resolveConfigFileProjectName(passedInRef.path); + } + ts.resolveProjectReferencePath = resolveProjectReferencePath; + function getResolutionDiagnostic(options, _a) { + var extension = _a.extension; + switch (extension) { + case ".ts": + case ".d.ts": + return undefined; + case ".tsx": + return needJsx(); + case ".jsx": + return needJsx() || needAllowJs(); + case ".js": + return needAllowJs(); + case ".json": + return needResolveJsonModule(); + } + function needJsx() { + return options.jsx ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set; + } + function needAllowJs() { + return options.allowJs || !ts.getStrictOptionValue(options, "noImplicitAny") ? undefined : ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type; + } + function needResolveJsonModule() { + return options.resolveJsonModule ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used; + } + } + ts.getResolutionDiagnostic = getResolutionDiagnostic; + function getModuleNames(_a) { + var imports = _a.imports, moduleAugmentations = _a.moduleAugmentations; + var res = imports.map(function (i) { return i.text; }); + for (var _i = 0, moduleAugmentations_1 = moduleAugmentations; _i < moduleAugmentations_1.length; _i++) { + var aug = moduleAugmentations_1[_i]; + if (aug.kind === 10) { + res.push(aug.text); + } + } + return res; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit) { + var outputFiles = []; + var emitResult = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit); + return { outputFiles: outputFiles, emitSkipped: emitResult.emitSkipped, exportedModulesFromDeclarationEmit: emitResult.exportedModulesFromDeclarationEmit }; + function writeFile(fileName, text, writeByteOrderMark) { + outputFiles.push({ name: fileName, writeByteOrderMark: writeByteOrderMark, text: text }); + } + } + ts.getFileEmitOutput = getFileEmitOutput; + var BuilderState; + (function (BuilderState) { + function getReferencedFileFromImportedModuleSymbol(symbol) { + if (symbol.declarations && symbol.declarations[0]) { + var declarationSourceFile = ts.getSourceFileOfNode(symbol.declarations[0]); + return declarationSourceFile && declarationSourceFile.resolvedPath; + } + } + function getReferencedFileFromImportLiteral(checker, importName) { + var symbol = checker.getSymbolAtLocation(importName); + return symbol && getReferencedFileFromImportedModuleSymbol(symbol); + } + function getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName) { + return ts.toPath(program.getProjectReferenceRedirect(fileName) || fileName, sourceFileDirectory, getCanonicalFileName); + } + function getReferencedFiles(program, sourceFile, getCanonicalFileName) { + var referencedFiles; + if (sourceFile.imports && sourceFile.imports.length > 0) { + var checker = program.getTypeChecker(); + for (var _i = 0, _a = sourceFile.imports; _i < _a.length; _i++) { + var importName = _a[_i]; + var declarationSourceFilePath = getReferencedFileFromImportLiteral(checker, importName); + if (declarationSourceFilePath) { + addReferencedFile(declarationSourceFilePath); + } + } + } + var sourceFileDirectory = ts.getDirectoryPath(sourceFile.resolvedPath); + if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) { + for (var _b = 0, _c = sourceFile.referencedFiles; _b < _c.length; _b++) { + var referencedFile = _c[_b]; + var referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName); + addReferencedFile(referencedPath); + } + } + if (sourceFile.resolvedTypeReferenceDirectiveNames) { + sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (resolvedTypeReferenceDirective) { + if (!resolvedTypeReferenceDirective) { + return; + } + var fileName = resolvedTypeReferenceDirective.resolvedFileName; + var typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName); + addReferencedFile(typeFilePath); + }); + } + if (sourceFile.moduleAugmentations.length) { + var checker = program.getTypeChecker(); + for (var _d = 0, _e = sourceFile.moduleAugmentations; _d < _e.length; _d++) { + var moduleName = _e[_d]; + if (!ts.isStringLiteral(moduleName)) { + continue; + } + var symbol = checker.getSymbolAtLocation(moduleName); + if (!symbol) { + continue; + } + addReferenceFromAmbientModule(symbol); + } + } + for (var _f = 0, _g = program.getTypeChecker().getAmbientModules(); _f < _g.length; _f++) { + var ambientModule = _g[_f]; + if (ambientModule.declarations.length > 1) { + addReferenceFromAmbientModule(ambientModule); + } + } + return referencedFiles; + function addReferenceFromAmbientModule(symbol) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var declarationSourceFile = ts.getSourceFileOfNode(declaration); + if (declarationSourceFile && + declarationSourceFile !== sourceFile) { + addReferencedFile(declarationSourceFile.resolvedPath); + } + } + } + function addReferencedFile(referencedPath) { + if (!referencedFiles) { + referencedFiles = ts.createMap(); + } + referencedFiles.set(referencedPath, true); + } + } + function canReuseOldState(newReferencedMap, oldState) { + return oldState && !oldState.referencedMap === !newReferencedMap; + } + BuilderState.canReuseOldState = canReuseOldState; + function create(newProgram, getCanonicalFileName, oldState) { + var fileInfos = ts.createMap(); + var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? ts.createMap() : undefined; + var exportedModulesMap = referencedMap ? ts.createMap() : undefined; + var hasCalledUpdateShapeSignature = ts.createMap(); + var useOldState = canReuseOldState(referencedMap, oldState); + for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) { + var sourceFile = _a[_i]; + var version_1 = ts.Debug.assertDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set"); + var oldInfo = useOldState ? oldState.fileInfos.get(sourceFile.resolvedPath) : undefined; + if (referencedMap) { + var newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName); + if (newReferences) { + referencedMap.set(sourceFile.resolvedPath, newReferences); + } + if (useOldState) { + var exportedModules = oldState.exportedModulesMap.get(sourceFile.resolvedPath); + if (exportedModules) { + exportedModulesMap.set(sourceFile.resolvedPath, exportedModules); + } + } + } + fileInfos.set(sourceFile.resolvedPath, { version: version_1, signature: oldInfo && oldInfo.signature }); + } + return { + fileInfos: fileInfos, + referencedMap: referencedMap, + exportedModulesMap: exportedModulesMap, + hasCalledUpdateShapeSignature: hasCalledUpdateShapeSignature + }; + } + BuilderState.create = create; + function releaseCache(state) { + state.allFilesExcludingDefaultLibraryFile = undefined; + state.allFileNames = undefined; + } + BuilderState.releaseCache = releaseCache; + function clone(state) { + var fileInfos = ts.createMap(); + state.fileInfos.forEach(function (value, key) { + fileInfos.set(key, __assign({}, value)); + }); + return { + fileInfos: fileInfos, + referencedMap: cloneMapOrUndefined(state.referencedMap), + exportedModulesMap: cloneMapOrUndefined(state.exportedModulesMap), + hasCalledUpdateShapeSignature: ts.cloneMap(state.hasCalledUpdateShapeSignature), + }; + } + BuilderState.clone = clone; + function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, cacheToUpdateSignature, exportedModulesMapCache) { + var signatureCache = cacheToUpdateSignature || ts.createMap(); + var sourceFile = programOfThisState.getSourceFileByPath(path); + if (!sourceFile) { + return ts.emptyArray; + } + if (!updateShapeSignature(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache)) { + return [sourceFile]; + } + var result = (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache); + if (!cacheToUpdateSignature) { + updateSignaturesFromCache(state, signatureCache); + } + return result; + } + BuilderState.getFilesAffectedBy = getFilesAffectedBy; + function updateSignaturesFromCache(state, signatureCache) { + signatureCache.forEach(function (signature, path) { + state.fileInfos.get(path).signature = signature; + state.hasCalledUpdateShapeSignature.set(path, true); + }); + } + BuilderState.updateSignaturesFromCache = updateSignaturesFromCache; + function updateShapeSignature(state, programOfThisState, sourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache) { + ts.Debug.assert(!!sourceFile); + ts.Debug.assert(!exportedModulesMapCache || !!state.exportedModulesMap, "Compute visible to outside map only if visibleToOutsideReferencedMap present in the state"); + if (state.hasCalledUpdateShapeSignature.has(sourceFile.resolvedPath) || cacheToUpdateSignature.has(sourceFile.resolvedPath)) { + return false; + } + var info = state.fileInfos.get(sourceFile.resolvedPath); + if (!info) + return ts.Debug.fail(); + var prevSignature = info.signature; + var latestSignature; + if (sourceFile.isDeclarationFile) { + latestSignature = sourceFile.version; + if (exportedModulesMapCache && latestSignature !== prevSignature) { + var references = state.referencedMap ? state.referencedMap.get(sourceFile.resolvedPath) : undefined; + exportedModulesMapCache.set(sourceFile.resolvedPath, references || false); + } + } + else { + var emitOutput_1 = getFileEmitOutput(programOfThisState, sourceFile, true, cancellationToken, undefined, true); + var firstDts_1 = emitOutput_1.outputFiles && + programOfThisState.getCompilerOptions().declarationMap ? + emitOutput_1.outputFiles.length > 1 ? emitOutput_1.outputFiles[1] : undefined : + emitOutput_1.outputFiles.length > 0 ? emitOutput_1.outputFiles[0] : undefined; + if (firstDts_1) { + ts.Debug.assert(ts.fileExtensionIs(firstDts_1.name, ".d.ts"), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); }); + latestSignature = computeHash(firstDts_1.text); + if (exportedModulesMapCache && latestSignature !== prevSignature) { + updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache); + } + } + else { + latestSignature = prevSignature; + } + } + cacheToUpdateSignature.set(sourceFile.resolvedPath, latestSignature); + return !prevSignature || latestSignature !== prevSignature; + } + BuilderState.updateShapeSignature = updateShapeSignature; + function updateExportedModules(sourceFile, exportedModulesFromDeclarationEmit, exportedModulesMapCache) { + if (!exportedModulesFromDeclarationEmit) { + exportedModulesMapCache.set(sourceFile.resolvedPath, false); + return; + } + var exportedModules; + exportedModulesFromDeclarationEmit.forEach(function (symbol) { return addExportedModule(getReferencedFileFromImportedModuleSymbol(symbol)); }); + exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules || false); + function addExportedModule(exportedModulePath) { + if (exportedModulePath) { + if (!exportedModules) { + exportedModules = ts.createMap(); + } + exportedModules.set(exportedModulePath, true); + } + } + } + function updateExportedFilesMapFromCache(state, exportedModulesMapCache) { + if (exportedModulesMapCache) { + ts.Debug.assert(!!state.exportedModulesMap); + exportedModulesMapCache.forEach(function (exportedModules, path) { + if (exportedModules) { + state.exportedModulesMap.set(path, exportedModules); + } + else { + state.exportedModulesMap.delete(path); + } + }); + } + } + BuilderState.updateExportedFilesMapFromCache = updateExportedFilesMapFromCache; + function getAllDependencies(state, programOfThisState, sourceFile) { + var compilerOptions = programOfThisState.getCompilerOptions(); + if (compilerOptions.outFile || compilerOptions.out) { + return getAllFileNames(state, programOfThisState); + } + if (!state.referencedMap || isFileAffectingGlobalScope(sourceFile)) { + return getAllFileNames(state, programOfThisState); + } + var seenMap = ts.createMap(); + var queue = [sourceFile.resolvedPath]; + while (queue.length) { + var path = queue.pop(); + if (!seenMap.has(path)) { + seenMap.set(path, true); + var references = state.referencedMap.get(path); + if (references) { + var iterator = references.keys(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + queue.push(iterResult.value); + } + } + } + } + return ts.arrayFrom(ts.mapDefinedIterator(seenMap.keys(), function (path) { + var file = programOfThisState.getSourceFileByPath(path); + return file ? file.fileName : path; + })); + } + BuilderState.getAllDependencies = getAllDependencies; + function getAllFileNames(state, programOfThisState) { + if (!state.allFileNames) { + var sourceFiles = programOfThisState.getSourceFiles(); + state.allFileNames = sourceFiles === ts.emptyArray ? ts.emptyArray : sourceFiles.map(function (file) { return file.fileName; }); + } + return state.allFileNames; + } + function getReferencedByPaths(state, referencedFilePath) { + return ts.arrayFrom(ts.mapDefinedIterator(state.referencedMap.entries(), function (_a) { + var filePath = _a[0], referencesInFile = _a[1]; + return referencesInFile.has(referencedFilePath) ? filePath : undefined; + })); + } + BuilderState.getReferencedByPaths = getReferencedByPaths; + function containsOnlyAmbientModules(sourceFile) { + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (!ts.isModuleWithStringLiteralName(statement)) { + return false; + } + } + return true; + } + function containsGlobalScopeAugmentation(sourceFile) { + return ts.some(sourceFile.moduleAugmentations, function (augmentation) { return ts.isGlobalScopeAugmentation(augmentation.parent); }); + } + function isFileAffectingGlobalScope(sourceFile) { + return containsGlobalScopeAugmentation(sourceFile) || + !ts.isExternalModule(sourceFile) && !containsOnlyAmbientModules(sourceFile); + } + function getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, firstSourceFile) { + if (state.allFilesExcludingDefaultLibraryFile) { + return state.allFilesExcludingDefaultLibraryFile; + } + var result; + addSourceFile(firstSourceFile); + for (var _i = 0, _a = programOfThisState.getSourceFiles(); _i < _a.length; _i++) { + var sourceFile = _a[_i]; + if (sourceFile !== firstSourceFile) { + addSourceFile(sourceFile); + } + } + state.allFilesExcludingDefaultLibraryFile = result || ts.emptyArray; + return state.allFilesExcludingDefaultLibraryFile; + function addSourceFile(sourceFile) { + if (!programOfThisState.isSourceFileDefaultLibrary(sourceFile)) { + (result || (result = [])).push(sourceFile); + } + } + } + function getFilesAffectedByUpdatedShapeWhenNonModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape) { + var compilerOptions = programOfThisState.getCompilerOptions(); + if (compilerOptions && (compilerOptions.out || compilerOptions.outFile)) { + return [sourceFileWithUpdatedShape]; + } + return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape); + } + function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache) { + if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) { + return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape); + } + var compilerOptions = programOfThisState.getCompilerOptions(); + if (compilerOptions && (compilerOptions.isolatedModules || compilerOptions.out || compilerOptions.outFile)) { + return [sourceFileWithUpdatedShape]; + } + var seenFileNamesMap = ts.createMap(); + seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape); + var queue = getReferencedByPaths(state, sourceFileWithUpdatedShape.resolvedPath); + while (queue.length > 0) { + var currentPath = queue.pop(); + if (!seenFileNamesMap.has(currentPath)) { + var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath); + seenFileNamesMap.set(currentPath, currentSourceFile); + if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache)) { + queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath)); + } + } + } + return ts.arrayFrom(ts.mapDefinedIterator(seenFileNamesMap.values(), function (value) { return value; })); + } + })(BuilderState = ts.BuilderState || (ts.BuilderState = {})); + function cloneMapOrUndefined(map) { + return map ? ts.cloneMap(map) : undefined; + } + ts.cloneMapOrUndefined = cloneMapOrUndefined; +})(ts || (ts = {})); +var ts; +(function (ts) { + function hasSameKeys(map1, map2) { + return map1 === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !ts.forEachKey(map1, function (key) { return !map2.has(key); }); + } + function createBuilderProgramState(newProgram, getCanonicalFileName, oldState) { + var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState); + state.program = newProgram; + var compilerOptions = newProgram.getCompilerOptions(); + state.compilerOptions = compilerOptions; + if (!compilerOptions.outFile && !compilerOptions.out) { + state.semanticDiagnosticsPerFile = ts.createMap(); + } + state.changedFilesSet = ts.createMap(); + var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState); + var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined; + var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile && + !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions); + if (useOldState) { + if (!oldState.currentChangedFilePath) { + var affectedSignatures = oldState.currentAffectedFilesSignatures; + ts.Debug.assert(!oldState.affectedFiles && (!affectedSignatures || !affectedSignatures.size), "Cannot reuse if only few affected files of currentChangedFile were iterated"); + } + var changedFilesSet = oldState.changedFilesSet; + if (canCopySemanticDiagnostics) { + ts.Debug.assert(!changedFilesSet || !ts.forEachKey(changedFilesSet, function (path) { return oldState.semanticDiagnosticsPerFile.has(path); }), "Semantic diagnostics shouldnt be available for changed files"); + } + if (changedFilesSet) { + ts.copyEntries(changedFilesSet, state.changedFilesSet); + } + if (!compilerOptions.outFile && !compilerOptions.out && oldState.affectedFilesPendingEmit) { + state.affectedFilesPendingEmit = oldState.affectedFilesPendingEmit.slice(); + state.affectedFilesPendingEmitKind = ts.cloneMapOrUndefined(oldState.affectedFilesPendingEmitKind); + state.affectedFilesPendingEmitIndex = oldState.affectedFilesPendingEmitIndex; + } + } + var referencedMap = state.referencedMap; + var oldReferencedMap = useOldState ? oldState.referencedMap : undefined; + var copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck; + var copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck; + state.fileInfos.forEach(function (info, sourceFilePath) { + var oldInfo; + var newReferences; + if (!useOldState || + !(oldInfo = oldState.fileInfos.get(sourceFilePath)) || + oldInfo.version !== info.version || + !hasSameKeys(newReferences = referencedMap && referencedMap.get(sourceFilePath), oldReferencedMap && oldReferencedMap.get(sourceFilePath)) || + newReferences && ts.forEachKey(newReferences, function (path) { return !state.fileInfos.has(path) && oldState.fileInfos.has(path); })) { + state.changedFilesSet.set(sourceFilePath, true); + } + else if (canCopySemanticDiagnostics) { + var sourceFile = newProgram.getSourceFileByPath(sourceFilePath); + if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics) { + return; + } + if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics) { + return; + } + var diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath); + if (diagnostics) { + state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics); + if (!state.semanticDiagnosticsFromOldState) { + state.semanticDiagnosticsFromOldState = ts.createMap(); + } + state.semanticDiagnosticsFromOldState.set(sourceFilePath, true); + } + } + }); + if (oldCompilerOptions && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) { + newProgram.getSourceFiles().forEach(function (f) { return addToAffectedFilesPendingEmit(state, f.resolvedPath, 1); }); + ts.Debug.assert(state.seenAffectedFiles === undefined); + state.seenAffectedFiles = ts.createMap(); + } + state.emittedBuildInfo = !state.changedFilesSet.size && !state.affectedFilesPendingEmit; + return state; + } + function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) { + if (!diagnostics.length) + return ts.emptyArray; + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())); + return diagnostics.map(function (diagnostic) { + var result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath); + result.reportsUnnecessary = diagnostic.reportsUnnecessary; + result.source = diagnostic.source; + var relatedInformation = diagnostic.relatedInformation; + result.relatedInformation = relatedInformation ? + relatedInformation.length ? + relatedInformation.map(function (r) { return convertToDiagnosticRelatedInformation(r, newProgram, toPath); }) : + ts.emptyArray : + undefined; + return result; + }); + function toPath(path) { + return ts.toPath(path, buildInfoDirectory, getCanonicalFileName); + } + } + function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath) { + var file = diagnostic.file; + return __assign(__assign({}, diagnostic), { file: file ? newProgram.getSourceFileByPath(toPath(file)) : undefined }); + } + function releaseCache(state) { + ts.BuilderState.releaseCache(state); + state.program = undefined; + } + function cloneBuilderProgramState(state) { + var newState = ts.BuilderState.clone(state); + newState.semanticDiagnosticsPerFile = ts.cloneMapOrUndefined(state.semanticDiagnosticsPerFile); + newState.changedFilesSet = ts.cloneMap(state.changedFilesSet); + newState.affectedFiles = state.affectedFiles; + newState.affectedFilesIndex = state.affectedFilesIndex; + newState.currentChangedFilePath = state.currentChangedFilePath; + newState.currentAffectedFilesSignatures = ts.cloneMapOrUndefined(state.currentAffectedFilesSignatures); + newState.currentAffectedFilesExportedModulesMap = ts.cloneMapOrUndefined(state.currentAffectedFilesExportedModulesMap); + newState.seenAffectedFiles = ts.cloneMapOrUndefined(state.seenAffectedFiles); + newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles; + newState.semanticDiagnosticsFromOldState = ts.cloneMapOrUndefined(state.semanticDiagnosticsFromOldState); + newState.program = state.program; + newState.compilerOptions = state.compilerOptions; + newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice(); + newState.affectedFilesPendingEmitKind = ts.cloneMapOrUndefined(state.affectedFilesPendingEmitKind); + newState.affectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex; + newState.seenEmittedFiles = ts.cloneMapOrUndefined(state.seenEmittedFiles); + newState.programEmitComplete = state.programEmitComplete; + return newState; + } + function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) { + ts.Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath)); + } + function getNextAffectedFile(state, cancellationToken, computeHash) { + while (true) { + var affectedFiles = state.affectedFiles; + if (affectedFiles) { + var seenAffectedFiles = state.seenAffectedFiles; + var affectedFilesIndex = state.affectedFilesIndex; + while (affectedFilesIndex < affectedFiles.length) { + var affectedFile = affectedFiles[affectedFilesIndex]; + if (!seenAffectedFiles.has(affectedFile.resolvedPath)) { + state.affectedFilesIndex = affectedFilesIndex; + handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash); + return affectedFile; + } + affectedFilesIndex++; + } + state.changedFilesSet.delete(state.currentChangedFilePath); + state.currentChangedFilePath = undefined; + ts.BuilderState.updateSignaturesFromCache(state, state.currentAffectedFilesSignatures); + state.currentAffectedFilesSignatures.clear(); + ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap); + state.affectedFiles = undefined; + } + var nextKey = state.changedFilesSet.keys().next(); + if (nextKey.done) { + return undefined; + } + var program = ts.Debug.assertDefined(state.program); + var compilerOptions = program.getCompilerOptions(); + if (compilerOptions.outFile || compilerOptions.out) { + ts.Debug.assert(!state.semanticDiagnosticsPerFile); + return program; + } + state.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures || ts.createMap(); + if (state.exportedModulesMap) { + state.currentAffectedFilesExportedModulesMap = state.currentAffectedFilesExportedModulesMap || ts.createMap(); + } + state.affectedFiles = ts.BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap); + state.currentChangedFilePath = nextKey.value; + state.affectedFilesIndex = 0; + state.seenAffectedFiles = state.seenAffectedFiles || ts.createMap(); + } + } + function getNextAffectedFilePendingEmit(state) { + var affectedFilesPendingEmit = state.affectedFilesPendingEmit; + if (affectedFilesPendingEmit) { + var seenEmittedFiles = state.seenEmittedFiles || (state.seenEmittedFiles = ts.createMap()); + for (var i = state.affectedFilesPendingEmitIndex; i < affectedFilesPendingEmit.length; i++) { + var affectedFile = ts.Debug.assertDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]); + if (affectedFile) { + var seenKind = seenEmittedFiles.get(affectedFile.resolvedPath); + var emitKind = ts.Debug.assertDefined(ts.Debug.assertDefined(state.affectedFilesPendingEmitKind).get(affectedFile.resolvedPath)); + if (seenKind === undefined || seenKind < emitKind) { + state.affectedFilesPendingEmitIndex = i; + return { affectedFile: affectedFile, emitKind: emitKind }; + } + } + } + state.affectedFilesPendingEmit = undefined; + state.affectedFilesPendingEmitKind = undefined; + state.affectedFilesPendingEmitIndex = undefined; + } + return undefined; + } + function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash) { + removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath); + if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) { + if (!state.cleanedDiagnosticsOfLibFiles) { + state.cleanedDiagnosticsOfLibFiles = true; + var program_1 = ts.Debug.assertDefined(state.program); + var options_2 = program_1.getCompilerOptions(); + ts.forEach(program_1.getSourceFiles(), function (f) { + return program_1.isSourceFileDefaultLibrary(f) && + !ts.skipTypeChecking(f, options_2, program_1) && + removeSemanticDiagnosticsOf(state, f.resolvedPath); + }); + } + return; + } + if (!state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) { + forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, function (state, path) { return handleDtsMayChangeOf(state, path, cancellationToken, computeHash); }); + } + } + function handleDtsMayChangeOf(state, path, cancellationToken, computeHash) { + removeSemanticDiagnosticsOf(state, path); + if (!state.changedFilesSet.has(path)) { + var program = ts.Debug.assertDefined(state.program); + var sourceFile = program.getSourceFileByPath(path); + if (sourceFile) { + ts.BuilderState.updateShapeSignature(state, program, sourceFile, ts.Debug.assertDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap); + if (ts.getEmitDeclarations(state.compilerOptions)) { + addToAffectedFilesPendingEmit(state, path, 0); + } + } + } + return false; + } + function removeSemanticDiagnosticsOf(state, path) { + if (!state.semanticDiagnosticsFromOldState) { + return true; + } + state.semanticDiagnosticsFromOldState.delete(path); + state.semanticDiagnosticsPerFile.delete(path); + return !state.semanticDiagnosticsFromOldState.size; + } + function isChangedSignagure(state, path) { + var newSignature = ts.Debug.assertDefined(state.currentAffectedFilesSignatures).get(path); + var oldSignagure = ts.Debug.assertDefined(state.fileInfos.get(path)).signature; + return newSignature !== oldSignagure; + } + function forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, fn) { + if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath)) { + return; + } + if (!isChangedSignagure(state, affectedFile.resolvedPath)) + return; + if (state.compilerOptions.isolatedModules) { + var seenFileNamesMap = ts.createMap(); + seenFileNamesMap.set(affectedFile.resolvedPath, true); + var queue = ts.BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath); + while (queue.length > 0) { + var currentPath = queue.pop(); + if (!seenFileNamesMap.has(currentPath)) { + seenFileNamesMap.set(currentPath, true); + var result = fn(state, currentPath); + if (result && isChangedSignagure(state, currentPath)) { + var currentSourceFile = ts.Debug.assertDefined(state.program).getSourceFileByPath(currentPath); + queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath)); + } + } + } + } + ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap); + var seenFileAndExportsOfFile = ts.createMap(); + if (ts.forEachEntry(state.currentAffectedFilesExportedModulesMap, function (exportedModules, exportedFromPath) { + return exportedModules && + exportedModules.has(affectedFile.resolvedPath) && + forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn); + })) { + return; + } + ts.forEachEntry(state.exportedModulesMap, function (exportedModules, exportedFromPath) { + return !state.currentAffectedFilesExportedModulesMap.has(exportedFromPath) && + exportedModules.has(affectedFile.resolvedPath) && + forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn); + }); + } + function forEachFilesReferencingPath(state, referencedPath, seenFileAndExportsOfFile, fn) { + return ts.forEachEntry(state.referencedMap, function (referencesInFile, filePath) { + return referencesInFile.has(referencedPath) && forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn); + }); + } + function forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn) { + if (!ts.addToSeen(seenFileAndExportsOfFile, filePath)) { + return false; + } + if (fn(state, filePath)) { + return true; + } + ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap); + if (ts.forEachEntry(state.currentAffectedFilesExportedModulesMap, function (exportedModules, exportedFromPath) { + return exportedModules && + exportedModules.has(filePath) && + forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn); + })) { + return true; + } + if (ts.forEachEntry(state.exportedModulesMap, function (exportedModules, exportedFromPath) { + return !state.currentAffectedFilesExportedModulesMap.has(exportedFromPath) && + exportedModules.has(filePath) && + forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn); + })) { + return true; + } + return !!ts.forEachEntry(state.referencedMap, function (referencesInFile, referencingFilePath) { + return referencesInFile.has(filePath) && + !seenFileAndExportsOfFile.has(referencingFilePath) && + fn(state, referencingFilePath); + }); + } + function doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit) { + if (isBuildInfoEmit) { + state.emittedBuildInfo = true; + } + else if (affected === state.program) { + state.changedFilesSet.clear(); + state.programEmitComplete = true; + } + else { + state.seenAffectedFiles.set(affected.resolvedPath, true); + if (emitKind !== undefined) { + (state.seenEmittedFiles || (state.seenEmittedFiles = ts.createMap())).set(affected.resolvedPath, emitKind); + } + if (isPendingEmit) { + state.affectedFilesPendingEmitIndex++; + } + else { + state.affectedFilesIndex++; + } + } + } + function toAffectedFileResult(state, result, affected) { + doneWithAffectedFile(state, affected); + return { result: result, affected: affected }; + } + function toAffectedFileEmitResult(state, result, affected, emitKind, isPendingEmit, isBuildInfoEmit) { + doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit); + return { result: result, affected: affected }; + } + function getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken) { + return ts.concatenate(getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken), ts.Debug.assertDefined(state.program).getProgramDiagnostics(sourceFile)); + } + function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken) { + var path = sourceFile.resolvedPath; + if (state.semanticDiagnosticsPerFile) { + var cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path); + if (cachedDiagnostics) { + return cachedDiagnostics; + } + } + var diagnostics = ts.Debug.assertDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken); + if (state.semanticDiagnosticsPerFile) { + state.semanticDiagnosticsPerFile.set(path, diagnostics); + } + return diagnostics; + } + function getProgramBuildInfo(state, getCanonicalFileName) { + if (state.compilerOptions.outFile || state.compilerOptions.out) + return undefined; + var currentDirectory = ts.Debug.assertDefined(state.program).getCurrentDirectory(); + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory)); + var fileInfos = {}; + state.fileInfos.forEach(function (value, key) { + var signature = state.currentAffectedFilesSignatures && state.currentAffectedFilesSignatures.get(key); + fileInfos[relativeToBuildInfo(key)] = signature === undefined ? value : { version: value.version, signature: signature }; + }); + var result = { + fileInfos: fileInfos, + options: convertToReusableCompilerOptions(state.compilerOptions, relativeToBuildInfoEnsuringAbsolutePath) + }; + if (state.referencedMap) { + var referencedMap_1 = {}; + state.referencedMap.forEach(function (value, key) { + referencedMap_1[relativeToBuildInfo(key)] = ts.arrayFrom(value.keys(), relativeToBuildInfo); + }); + result.referencedMap = referencedMap_1; + } + if (state.exportedModulesMap) { + var exportedModulesMap_1 = {}; + state.exportedModulesMap.forEach(function (value, key) { + var newValue = state.currentAffectedFilesExportedModulesMap && state.currentAffectedFilesExportedModulesMap.get(key); + if (newValue === undefined) + exportedModulesMap_1[relativeToBuildInfo(key)] = ts.arrayFrom(value.keys(), relativeToBuildInfo); + else if (newValue) + exportedModulesMap_1[relativeToBuildInfo(key)] = ts.arrayFrom(newValue.keys(), relativeToBuildInfo); + }); + result.exportedModulesMap = exportedModulesMap_1; + } + if (state.semanticDiagnosticsPerFile) { + var semanticDiagnosticsPerFile_1 = []; + state.semanticDiagnosticsPerFile.forEach(function (value, key) { return semanticDiagnosticsPerFile_1.push(value.length ? + [ + relativeToBuildInfo(key), + state.hasReusableDiagnostic ? + value : + convertToReusableDiagnostics(value, relativeToBuildInfo) + ] : + relativeToBuildInfo(key)); }); + result.semanticDiagnosticsPerFile = semanticDiagnosticsPerFile_1; + } + return result; + function relativeToBuildInfoEnsuringAbsolutePath(path) { + return relativeToBuildInfo(ts.getNormalizedAbsolutePath(path, currentDirectory)); + } + function relativeToBuildInfo(path) { + return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName)); + } + } + function convertToReusableCompilerOptions(options, relativeToBuildInfo) { + var result = {}; + var optionsNameMap = ts.getOptionsNameMap().optionsNameMap; + for (var name in options) { + if (ts.hasProperty(options, name)) { + result[name] = convertToReusableCompilerOptionValue(optionsNameMap.get(name.toLowerCase()), options[name], relativeToBuildInfo); + } + } + if (result.configFilePath) { + result.configFilePath = relativeToBuildInfo(result.configFilePath); + } + return result; + } + function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) { + if (option) { + if (option.type === "list") { + var values = value; + if (option.element.isFilePath && values.length) { + return values.map(relativeToBuildInfo); + } + } + else if (option.isFilePath) { + return relativeToBuildInfo(value); + } + } + return value; + } + function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) { + ts.Debug.assert(!!diagnostics.length); + return diagnostics.map(function (diagnostic) { + var result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo); + result.reportsUnnecessary = diagnostic.reportsUnnecessary; + result.source = diagnostic.source; + var relatedInformation = diagnostic.relatedInformation; + result.relatedInformation = relatedInformation ? + relatedInformation.length ? + relatedInformation.map(function (r) { return convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo); }) : + ts.emptyArray : + undefined; + return result; + }); + } + function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) { + var file = diagnostic.file; + return __assign(__assign({}, diagnostic), { file: file ? relativeToBuildInfo(file.resolvedPath) : undefined }); + } + var BuilderProgramKind; + (function (BuilderProgramKind) { + BuilderProgramKind[BuilderProgramKind["SemanticDiagnosticsBuilderProgram"] = 0] = "SemanticDiagnosticsBuilderProgram"; + BuilderProgramKind[BuilderProgramKind["EmitAndSemanticDiagnosticsBuilderProgram"] = 1] = "EmitAndSemanticDiagnosticsBuilderProgram"; + })(BuilderProgramKind = ts.BuilderProgramKind || (ts.BuilderProgramKind = {})); + function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + var host; + var newProgram; + var oldProgram; + if (newProgramOrRootNames === undefined) { + ts.Debug.assert(hostOrOptions === undefined); + host = oldProgramOrHost; + oldProgram = configFileParsingDiagnosticsOrOldProgram; + ts.Debug.assert(!!oldProgram); + newProgram = oldProgram.getProgram(); + } + else if (ts.isArray(newProgramOrRootNames)) { + oldProgram = configFileParsingDiagnosticsOrOldProgram; + newProgram = ts.createProgram({ + rootNames: newProgramOrRootNames, + options: hostOrOptions, + host: oldProgramOrHost, + oldProgram: oldProgram && oldProgram.getProgramOrUndefined(), + configFileParsingDiagnostics: configFileParsingDiagnostics, + projectReferences: projectReferences + }); + host = oldProgramOrHost; + } + else { + newProgram = newProgramOrRootNames; + host = hostOrOptions; + oldProgram = oldProgramOrHost; + configFileParsingDiagnostics = configFileParsingDiagnosticsOrOldProgram; + } + return { host: host, newProgram: newProgram, oldProgram: oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || ts.emptyArray }; + } + ts.getBuilderCreationParameters = getBuilderCreationParameters; + function createBuilderProgram(kind, _a) { + var newProgram = _a.newProgram, host = _a.host, oldProgram = _a.oldProgram, configFileParsingDiagnostics = _a.configFileParsingDiagnostics; + var oldState = oldProgram && oldProgram.getState(); + if (oldState && newProgram === oldState.program && configFileParsingDiagnostics === newProgram.getConfigFileParsingDiagnostics()) { + newProgram = undefined; + oldState = undefined; + return oldProgram; + } + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var computeHash = host.createHash || ts.generateDjb2Hash; + var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState); + var backupState; + newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); }; + newProgram = undefined; + oldProgram = undefined; + oldState = undefined; + var builderProgram = createRedirectedBuilderProgram(state, configFileParsingDiagnostics); + builderProgram.getState = function () { return state; }; + builderProgram.backupState = function () { + ts.Debug.assert(backupState === undefined); + backupState = cloneBuilderProgramState(state); + }; + builderProgram.restoreState = function () { + state = ts.Debug.assertDefined(backupState); + backupState = undefined; + }; + builderProgram.getAllDependencies = function (sourceFile) { return ts.BuilderState.getAllDependencies(state, ts.Debug.assertDefined(state.program), sourceFile); }; + builderProgram.getSemanticDiagnostics = getSemanticDiagnostics; + builderProgram.emit = emit; + builderProgram.releaseProgram = function () { + releaseCache(state); + backupState = undefined; + }; + if (kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram) { + builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile; + } + else if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile; + builderProgram.emitNextAffectedFile = emitNextAffectedFile; + } + else { + ts.notImplemented(); + } + return builderProgram; + function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var affected = getNextAffectedFile(state, cancellationToken, computeHash); + var emitKind = 1; + var isPendingEmitFile = false; + if (!affected) { + if (!state.compilerOptions.out && !state.compilerOptions.outFile) { + var pendingAffectedFile = getNextAffectedFilePendingEmit(state); + if (!pendingAffectedFile) { + if (state.emittedBuildInfo) { + return undefined; + } + var affected_1 = ts.Debug.assertDefined(state.program); + return toAffectedFileEmitResult(state, affected_1.emitBuildInfo(writeFile || ts.maybeBind(host, host.writeFile), cancellationToken), affected_1, 1, false, true); + } + (affected = pendingAffectedFile.affectedFile, emitKind = pendingAffectedFile.emitKind); + isPendingEmitFile = true; + } + else { + var program = ts.Debug.assertDefined(state.program); + if (state.programEmitComplete) + return undefined; + affected = program; + } + } + return toAffectedFileEmitResult(state, ts.Debug.assertDefined(state.program).emit(affected === state.program ? undefined : affected, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0, customTransformers), affected, emitKind, isPendingEmitFile); + } + function emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile); + var result = ts.handleNoEmitOptions(builderProgram, targetSourceFile, cancellationToken); + if (result) + return result; + if (!targetSourceFile) { + var sourceMaps = []; + var emitSkipped = false; + var diagnostics = void 0; + var emittedFiles = []; + var affectedEmitResult = void 0; + while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) { + emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped; + diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics); + emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles); + sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps); + } + return { + emitSkipped: emitSkipped, + diagnostics: diagnostics || ts.emptyArray, + emittedFiles: emittedFiles, + sourceMaps: sourceMaps + }; + } + } + return ts.Debug.assertDefined(state.program).emit(targetSourceFile, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers); + } + function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) { + while (true) { + var affected = getNextAffectedFile(state, cancellationToken, computeHash); + if (!affected) { + return undefined; + } + else if (affected === state.program) { + return toAffectedFileResult(state, state.program.getSemanticDiagnostics(undefined, cancellationToken), affected); + } + if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + addToAffectedFilesPendingEmit(state, affected.resolvedPath, 1); + } + if (ignoreSourceFile && ignoreSourceFile(affected)) { + doneWithAffectedFile(state, affected); + continue; + } + return toAffectedFileResult(state, getSemanticDiagnosticsOfFile(state, affected, cancellationToken), affected); + } + } + function getSemanticDiagnostics(sourceFile, cancellationToken) { + assertSourceFileOkWithoutNextAffectedCall(state, sourceFile); + var compilerOptions = ts.Debug.assertDefined(state.program).getCompilerOptions(); + if (compilerOptions.outFile || compilerOptions.out) { + ts.Debug.assert(!state.semanticDiagnosticsPerFile); + return ts.Debug.assertDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken); + } + if (sourceFile) { + return getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken); + } + while (getSemanticDiagnosticsOfNextAffectedFile(cancellationToken)) { + } + var diagnostics; + for (var _i = 0, _a = ts.Debug.assertDefined(state.program).getSourceFiles(); _i < _a.length; _i++) { + var sourceFile_1 = _a[_i]; + diagnostics = ts.addRange(diagnostics, getSemanticDiagnosticsOfFile(state, sourceFile_1, cancellationToken)); + } + return diagnostics || ts.emptyArray; + } + } + ts.createBuilderProgram = createBuilderProgram; + function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) { + if (!state.affectedFilesPendingEmit) + state.affectedFilesPendingEmit = []; + if (!state.affectedFilesPendingEmitKind) + state.affectedFilesPendingEmitKind = ts.createMap(); + var existingKind = state.affectedFilesPendingEmitKind.get(affectedFilePendingEmit); + state.affectedFilesPendingEmit.push(affectedFilePendingEmit); + state.affectedFilesPendingEmitKind.set(affectedFilePendingEmit, existingKind || kind); + if (state.affectedFilesPendingEmitIndex === undefined) { + state.affectedFilesPendingEmitIndex = 0; + } + } + function getMapOfReferencedSet(mapLike, toPath) { + if (!mapLike) + return undefined; + var map = ts.createMap(); + for (var key in mapLike) { + if (ts.hasProperty(mapLike, key)) { + map.set(toPath(key), ts.arrayToSet(mapLike[key], toPath)); + } + } + return map; + } + function createBuildProgramUsingProgramBuildInfo(program, buildInfoPath, host) { + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var fileInfos = ts.createMap(); + for (var key in program.fileInfos) { + if (ts.hasProperty(program.fileInfos, key)) { + fileInfos.set(toPath(key), program.fileInfos[key]); + } + } + var state = { + fileInfos: fileInfos, + compilerOptions: ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath), + referencedMap: getMapOfReferencedSet(program.referencedMap, toPath), + exportedModulesMap: getMapOfReferencedSet(program.exportedModulesMap, toPath), + semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toPath(ts.isString(value) ? value : value[0]); }, function (value) { return ts.isString(value) ? ts.emptyArray : value[1]; }), + hasReusableDiagnostic: true + }; + return { + getState: function () { return state; }, + backupState: ts.noop, + restoreState: ts.noop, + getProgram: ts.notImplemented, + getProgramOrUndefined: ts.returnUndefined, + releaseProgram: ts.noop, + getCompilerOptions: function () { return state.compilerOptions; }, + getSourceFile: ts.notImplemented, + getSourceFiles: ts.notImplemented, + getOptionsDiagnostics: ts.notImplemented, + getGlobalDiagnostics: ts.notImplemented, + getConfigFileParsingDiagnostics: ts.notImplemented, + getSyntacticDiagnostics: ts.notImplemented, + getDeclarationDiagnostics: ts.notImplemented, + getSemanticDiagnostics: ts.notImplemented, + emit: ts.notImplemented, + getAllDependencies: ts.notImplemented, + getCurrentDirectory: ts.notImplemented, + emitNextAffectedFile: ts.notImplemented, + getSemanticDiagnosticsOfNextAffectedFile: ts.notImplemented, + close: ts.noop, + }; + function toPath(path) { + return ts.toPath(path, buildInfoDirectory, getCanonicalFileName); + } + function toAbsolutePath(path) { + return ts.getNormalizedAbsolutePath(path, buildInfoDirectory); + } + } + ts.createBuildProgramUsingProgramBuildInfo = createBuildProgramUsingProgramBuildInfo; + function createRedirectedBuilderProgram(state, configFileParsingDiagnostics) { + return { + getState: ts.notImplemented, + backupState: ts.noop, + restoreState: ts.noop, + getProgram: getProgram, + getProgramOrUndefined: function () { return state.program; }, + releaseProgram: function () { return state.program = undefined; }, + getCompilerOptions: function () { return state.compilerOptions; }, + getSourceFile: function (fileName) { return getProgram().getSourceFile(fileName); }, + getSourceFiles: function () { return getProgram().getSourceFiles(); }, + getOptionsDiagnostics: function (cancellationToken) { return getProgram().getOptionsDiagnostics(cancellationToken); }, + getGlobalDiagnostics: function (cancellationToken) { return getProgram().getGlobalDiagnostics(cancellationToken); }, + getConfigFileParsingDiagnostics: function () { return configFileParsingDiagnostics; }, + getSyntacticDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getSyntacticDiagnostics(sourceFile, cancellationToken); }, + getDeclarationDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken); }, + getSemanticDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getSemanticDiagnostics(sourceFile, cancellationToken); }, + emit: function (sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers) { return getProgram().emit(sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers); }, + getAllDependencies: ts.notImplemented, + getCurrentDirectory: function () { return getProgram().getCurrentDirectory(); }, + close: ts.noop, + }; + function getProgram() { + return ts.Debug.assertDefined(state.program); + } + } + ts.createRedirectedBuilderProgram = createRedirectedBuilderProgram; +})(ts || (ts = {})); +var ts; +(function (ts) { + function createSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + return ts.createBuilderProgram(ts.BuilderProgramKind.SemanticDiagnosticsBuilderProgram, ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences)); + } + ts.createSemanticDiagnosticsBuilderProgram = createSemanticDiagnosticsBuilderProgram; + function createEmitAndSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + return ts.createBuilderProgram(ts.BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram, ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences)); + } + ts.createEmitAndSemanticDiagnosticsBuilderProgram = createEmitAndSemanticDiagnosticsBuilderProgram; + function createAbstractBuilder(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + var _a = ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences), newProgram = _a.newProgram, newConfigFileParsingDiagnostics = _a.configFileParsingDiagnostics; + return ts.createRedirectedBuilderProgram({ program: newProgram, compilerOptions: newProgram.getCompilerOptions() }, newConfigFileParsingDiagnostics); + } + ts.createAbstractBuilder = createAbstractBuilder; +})(ts || (ts = {})); +var ts; +(function (ts) { + function removeIgnoredPath(path) { + if (ts.endsWith(path, "/node_modules/.staging")) { + return ts.removeSuffix(path, "/.staging"); + } + return ts.some(ts.ignoredPaths, function (searchPath) { return ts.stringContains(path, searchPath); }) ? + undefined : + path; + } + ts.removeIgnoredPath = removeIgnoredPath; + function canWatchDirectory(dirPath) { + var rootLength = ts.getRootLength(dirPath); + if (dirPath.length === rootLength) { + return false; + } + var nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, rootLength); + if (nextDirectorySeparator === -1) { + return false; + } + var pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1); + var isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47; + if (isNonDirectorySeparatorRoot && + dirPath.search(/[a-zA-Z]:/) !== 0 && + pathPartForUserCheck.search(/[a-zA-z]\$\//) === 0) { + nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, nextDirectorySeparator + 1); + if (nextDirectorySeparator === -1) { + return false; + } + pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1); + } + if (isNonDirectorySeparatorRoot && + pathPartForUserCheck.search(/users\//i) !== 0) { + return true; + } + for (var searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) { + searchIndex = dirPath.indexOf(ts.directorySeparator, searchIndex) + 1; + if (searchIndex === 0) { + return false; + } + } + return true; + } + ts.canWatchDirectory = canWatchDirectory; + ts.maxNumberOfFilesToIterateForInvalidation = 256; + function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) { + var filesWithChangedSetOfUnresolvedImports; + var filesWithInvalidatedResolutions; + var filesWithInvalidatedNonRelativeUnresolvedImports; + var allFilesHaveInvalidatedResolution = false; + var nonRelativeExternalModuleResolutions = ts.createMultiMap(); + var getCurrentDirectory = ts.memoize(function () { return resolutionHost.getCurrentDirectory(); }); + var cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost(); + var resolvedModuleNames = ts.createMap(); + var perDirectoryResolvedModuleNames = ts.createCacheWithRedirects(); + var nonRelativeModuleNameCache = ts.createCacheWithRedirects(); + var moduleResolutionCache = ts.createModuleResolutionCacheWithMaps(perDirectoryResolvedModuleNames, nonRelativeModuleNameCache, getCurrentDirectory(), resolutionHost.getCanonicalFileName); + var resolvedTypeReferenceDirectives = ts.createMap(); + var perDirectoryResolvedTypeReferenceDirectives = ts.createCacheWithRedirects(); + var failedLookupDefaultExtensions = [".ts", ".tsx", ".js", ".jsx", ".json"]; + var customFailedLookupPaths = ts.createMap(); + var directoryWatchesOfFailedLookups = ts.createMap(); + var rootDir = rootDirForResolution && ts.removeTrailingDirectorySeparator(ts.getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory())); + var rootPath = (rootDir && resolutionHost.toPath(rootDir)); + var rootSplitLength = rootPath !== undefined ? rootPath.split(ts.directorySeparator).length : 0; + var typeRootsWatches = ts.createMap(); + return { + startRecordingFilesWithChangedResolutions: startRecordingFilesWithChangedResolutions, + finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions, + startCachingPerDirectoryResolution: clearPerDirectoryResolutions, + finishCachingPerDirectoryResolution: finishCachingPerDirectoryResolution, + resolveModuleNames: resolveModuleNames, + getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache, + resolveTypeReferenceDirectives: resolveTypeReferenceDirectives, + removeResolutionsFromProjectReferenceRedirects: removeResolutionsFromProjectReferenceRedirects, + removeResolutionsOfFile: removeResolutionsOfFile, + invalidateResolutionOfFile: invalidateResolutionOfFile, + setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports, + createHasInvalidatedResolution: createHasInvalidatedResolution, + updateTypeRootsWatch: updateTypeRootsWatch, + closeTypeRootsWatch: closeTypeRootsWatch, + clear: clear + }; + function getResolvedModule(resolution) { + return resolution.resolvedModule; + } + function getResolvedTypeReferenceDirective(resolution) { + return resolution.resolvedTypeReferenceDirective; + } + function isInDirectoryPath(dir, file) { + if (dir === undefined || file.length <= dir.length) { + return false; + } + return ts.startsWith(file, dir) && file[dir.length] === ts.directorySeparator; + } + function clear() { + ts.clearMap(directoryWatchesOfFailedLookups, ts.closeFileWatcherOf); + customFailedLookupPaths.clear(); + nonRelativeExternalModuleResolutions.clear(); + closeTypeRootsWatch(); + resolvedModuleNames.clear(); + resolvedTypeReferenceDirectives.clear(); + allFilesHaveInvalidatedResolution = false; + clearPerDirectoryResolutions(); + } + function startRecordingFilesWithChangedResolutions() { + filesWithChangedSetOfUnresolvedImports = []; + } + function finishRecordingFilesWithChangedResolutions() { + var collected = filesWithChangedSetOfUnresolvedImports; + filesWithChangedSetOfUnresolvedImports = undefined; + return collected; + } + function isFileWithInvalidatedNonRelativeUnresolvedImports(path) { + if (!filesWithInvalidatedNonRelativeUnresolvedImports) { + return false; + } + var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path); + return !!value && !!value.length; + } + function createHasInvalidatedResolution(forceAllFilesAsInvalidated) { + if (allFilesHaveInvalidatedResolution || forceAllFilesAsInvalidated) { + filesWithInvalidatedResolutions = undefined; + return ts.returnTrue; + } + var collected = filesWithInvalidatedResolutions; + filesWithInvalidatedResolutions = undefined; + return function (path) { return (!!collected && collected.has(path)) || + isFileWithInvalidatedNonRelativeUnresolvedImports(path); }; + } + function clearPerDirectoryResolutions() { + perDirectoryResolvedModuleNames.clear(); + nonRelativeModuleNameCache.clear(); + perDirectoryResolvedTypeReferenceDirectives.clear(); + nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions); + nonRelativeExternalModuleResolutions.clear(); + } + function finishCachingPerDirectoryResolution() { + allFilesHaveInvalidatedResolution = false; + filesWithInvalidatedNonRelativeUnresolvedImports = undefined; + clearPerDirectoryResolutions(); + directoryWatchesOfFailedLookups.forEach(function (watcher, path) { + if (watcher.refCount === 0) { + directoryWatchesOfFailedLookups.delete(path); + watcher.watcher.close(); + } + }); + } + function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference) { + var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference); + if (!resolutionHost.getGlobalCache) { + return primaryResult; + } + var globalCache = resolutionHost.getGlobalCache(); + if (globalCache !== undefined && !ts.isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && ts.extensionIsTS(primaryResult.resolvedModule.extension))) { + var _a = ts.loadModuleFromGlobalCache(ts.Debug.assertDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations; + if (resolvedModule) { + return { resolvedModule: resolvedModule, failedLookupLocations: ts.addRange(primaryResult.failedLookupLocations, failedLookupLocations) }; + } + } + return primaryResult; + } + function resolveNamesWithLocalCache(names, containingFile, redirectedReference, cache, perDirectoryCacheWithRedirects, loader, getResolutionWithResolvedFileName, shouldRetryResolution, reusedNames, logChanges) { + var path = resolutionHost.toPath(containingFile); + var resolutionsInFile = cache.get(path) || cache.set(path, ts.createMap()).get(path); + var dirPath = ts.getDirectoryPath(path); + var perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference); + var perDirectoryResolution = perDirectoryCache.get(dirPath); + if (!perDirectoryResolution) { + perDirectoryResolution = ts.createMap(); + perDirectoryCache.set(dirPath, perDirectoryResolution); + } + var resolvedModules = []; + var compilerOptions = resolutionHost.getCompilationSettings(); + var hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path); + var program = resolutionHost.getCurrentProgram(); + var oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile); + var unmatchedRedirects = oldRedirect ? + !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : + !!redirectedReference; + var seenNamesInFile = ts.createMap(); + for (var _i = 0, names_3 = names; _i < names_3.length; _i++) { + var name = names_3[_i]; + var resolution = resolutionsInFile.get(name); + if (!seenNamesInFile.has(name) && + allFilesHaveInvalidatedResolution || unmatchedRedirects || !resolution || resolution.isInvalidated || + (hasInvalidatedNonRelativeUnresolvedImport && !ts.isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) { + var existingResolution = resolution; + var resolutionInDirectory = perDirectoryResolution.get(name); + if (resolutionInDirectory) { + resolution = resolutionInDirectory; + } + else { + resolution = loader(name, containingFile, compilerOptions, resolutionHost, redirectedReference); + perDirectoryResolution.set(name, resolution); + } + resolutionsInFile.set(name, resolution); + watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution); + if (existingResolution) { + stopWatchFailedLookupLocationOfResolution(existingResolution); + } + if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) { + filesWithChangedSetOfUnresolvedImports.push(path); + logChanges = false; + } + } + ts.Debug.assert(resolution !== undefined && !resolution.isInvalidated); + seenNamesInFile.set(name, true); + resolvedModules.push(getResolutionWithResolvedFileName(resolution)); + } + resolutionsInFile.forEach(function (resolution, name) { + if (!seenNamesInFile.has(name) && !ts.contains(reusedNames, name)) { + stopWatchFailedLookupLocationOfResolution(resolution); + resolutionsInFile.delete(name); + } + }); + return resolvedModules; + function resolutionIsEqualTo(oldResolution, newResolution) { + if (oldResolution === newResolution) { + return true; + } + if (!oldResolution || !newResolution) { + return false; + } + var oldResult = getResolutionWithResolvedFileName(oldResolution); + var newResult = getResolutionWithResolvedFileName(newResolution); + if (oldResult === newResult) { + return true; + } + if (!oldResult || !newResult) { + return false; + } + return oldResult.resolvedFileName === newResult.resolvedFileName; + } + } + function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference) { + return resolveNamesWithLocalCache(typeDirectiveNames, containingFile, redirectedReference, resolvedTypeReferenceDirectives, perDirectoryResolvedTypeReferenceDirectives, ts.resolveTypeReferenceDirective, getResolvedTypeReferenceDirective, function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; }, undefined, false); + } + function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference) { + return resolveNamesWithLocalCache(moduleNames, containingFile, redirectedReference, resolvedModuleNames, perDirectoryResolvedModuleNames, resolveModuleName, getResolvedModule, function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); }, reusedNames, logChangesWhenResolvingModule); + } + function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile) { + var cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile)); + return cache && cache.get(moduleName); + } + function isNodeModulesDirectory(dirPath) { + return ts.endsWith(dirPath, "/node_modules"); + } + function isNodeModulesAtTypesDirectory(dirPath) { + return ts.endsWith(dirPath, "/node_modules/@types"); + } + function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath) { + if (isInDirectoryPath(rootPath, failedLookupLocationPath)) { + failedLookupLocation = ts.isRootedDiskPath(failedLookupLocation) ? ts.normalizePath(failedLookupLocation) : ts.getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory()); + var failedLookupPathSplit = failedLookupLocationPath.split(ts.directorySeparator); + var failedLookupSplit = failedLookupLocation.split(ts.directorySeparator); + ts.Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, "FailedLookup: " + failedLookupLocation + " failedLookupLocationPath: " + failedLookupLocationPath); + if (failedLookupPathSplit.length > rootSplitLength + 1) { + return { + dir: failedLookupSplit.slice(0, rootSplitLength + 1).join(ts.directorySeparator), + dirPath: failedLookupPathSplit.slice(0, rootSplitLength + 1).join(ts.directorySeparator) + }; + } + else { + return { + dir: rootDir, + dirPath: rootPath, + nonRecursive: false + }; + } + } + return getDirectoryToWatchFromFailedLookupLocationDirectory(ts.getDirectoryPath(ts.getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())), ts.getDirectoryPath(failedLookupLocationPath)); + } + function getDirectoryToWatchFromFailedLookupLocationDirectory(dir, dirPath) { + while (ts.pathContainsNodeModules(dirPath)) { + dir = ts.getDirectoryPath(dir); + dirPath = ts.getDirectoryPath(dirPath); + } + if (isNodeModulesDirectory(dirPath)) { + return canWatchDirectory(ts.getDirectoryPath(dirPath)) ? { dir: dir, dirPath: dirPath } : undefined; + } + var nonRecursive = true; + var subDirectoryPath, subDirectory; + if (rootPath !== undefined) { + while (!isInDirectoryPath(dirPath, rootPath)) { + var parentPath = ts.getDirectoryPath(dirPath); + if (parentPath === dirPath) { + break; + } + nonRecursive = false; + subDirectoryPath = dirPath; + subDirectory = dir; + dirPath = parentPath; + dir = ts.getDirectoryPath(dir); + } + } + return canWatchDirectory(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive: nonRecursive } : undefined; + } + function isPathWithDefaultFailedLookupExtension(path) { + return ts.fileExtensionIsOneOf(path, failedLookupDefaultExtensions); + } + function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution) { + if (resolution.failedLookupLocations && resolution.failedLookupLocations.length) { + if (resolution.refCount) { + resolution.refCount++; + } + else { + resolution.refCount = 1; + if (ts.isExternalModuleNameRelative(name)) { + watchFailedLookupLocationOfResolution(resolution); + } + else { + nonRelativeExternalModuleResolutions.add(name, resolution); + } + } + } + } + function watchFailedLookupLocationOfResolution(resolution) { + ts.Debug.assert(!!resolution.refCount); + var failedLookupLocations = resolution.failedLookupLocations; + var setAtRoot = false; + for (var _i = 0, failedLookupLocations_1 = failedLookupLocations; _i < failedLookupLocations_1.length; _i++) { + var failedLookupLocation = failedLookupLocations_1[_i]; + var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation); + var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath); + if (toWatch) { + var dir = toWatch.dir, dirPath = toWatch.dirPath, nonRecursive = toWatch.nonRecursive; + if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) { + var refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0; + customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1); + } + if (dirPath === rootPath) { + ts.Debug.assert(!nonRecursive); + setAtRoot = true; + } + else { + setDirectoryWatcher(dir, dirPath, nonRecursive); + } + } + } + if (setAtRoot) { + setDirectoryWatcher(rootDir, rootPath, true); + } + } + function setRefCountToUndefined(resolution) { + resolution.refCount = undefined; + } + function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) { + var program = resolutionHost.getCurrentProgram(); + var updateResolution = program && program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name) ? + setRefCountToUndefined : watchFailedLookupLocationOfResolution; + resolutions.forEach(updateResolution); + } + function setDirectoryWatcher(dir, dirPath, nonRecursive) { + var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath); + if (dirWatcher) { + ts.Debug.assert(!!nonRecursive === !!dirWatcher.nonRecursive); + dirWatcher.refCount++; + } + else { + directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive: nonRecursive }); + } + } + function stopWatchFailedLookupLocationOfResolution(resolution) { + if (!resolution.refCount) { + return; + } + resolution.refCount--; + if (resolution.refCount) { + return; + } + var failedLookupLocations = resolution.failedLookupLocations; + var removeAtRoot = false; + for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) { + var failedLookupLocation = failedLookupLocations_2[_i]; + var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation); + var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath); + if (toWatch) { + var dirPath = toWatch.dirPath; + var refCount = customFailedLookupPaths.get(failedLookupLocationPath); + if (refCount) { + if (refCount === 1) { + customFailedLookupPaths.delete(failedLookupLocationPath); + } + else { + ts.Debug.assert(refCount > 1); + customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1); + } + } + if (dirPath === rootPath) { + removeAtRoot = true; + } + else { + removeDirectoryWatcher(dirPath); + } + } + } + if (removeAtRoot) { + removeDirectoryWatcher(rootPath); + } + } + function removeDirectoryWatcher(dirPath) { + var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath); + dirWatcher.refCount--; + } + function createDirectoryWatcher(directory, dirPath, nonRecursive) { + return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, function (fileOrDirectory) { + var fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory); + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + if (!allFilesHaveInvalidatedResolution && invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath)) { + resolutionHost.onInvalidatedResolution(); + } + }, nonRecursive ? 0 : 1); + } + function removeResolutionsOfFileFromCache(cache, filePath) { + var resolutions = cache.get(filePath); + if (resolutions) { + resolutions.forEach(stopWatchFailedLookupLocationOfResolution); + cache.delete(filePath); + } + } + function removeResolutionsFromProjectReferenceRedirects(filePath) { + if (!ts.fileExtensionIs(filePath, ".json")) { + return; + } + var program = resolutionHost.getCurrentProgram(); + if (!program) { + return; + } + var resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath); + if (!resolvedProjectReference) { + return; + } + resolvedProjectReference.commandLine.fileNames.forEach(function (f) { return removeResolutionsOfFile(resolutionHost.toPath(f)); }); + } + function removeResolutionsOfFile(filePath) { + removeResolutionsOfFileFromCache(resolvedModuleNames, filePath); + removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath); + } + function invalidateResolutionCache(cache, isInvalidatedResolution, getResolutionWithResolvedFileName) { + var seen = ts.createMap(); + cache.forEach(function (resolutions, containingFilePath) { + var dirPath = ts.getDirectoryPath(containingFilePath); + var seenInDir = seen.get(dirPath); + if (!seenInDir) { + seenInDir = ts.createMap(); + seen.set(dirPath, seenInDir); + } + resolutions.forEach(function (resolution, name) { + if (seenInDir.has(name)) { + return; + } + seenInDir.set(name, true); + if (!resolution.isInvalidated && isInvalidatedResolution(resolution, getResolutionWithResolvedFileName)) { + resolution.isInvalidated = true; + (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = ts.createMap())).set(containingFilePath, true); + if (containingFilePath.endsWith(ts.inferredTypesContainingFile)) { + resolutionHost.onChangedAutomaticTypeDirectiveNames(); + } + } + }); + }); + } + function hasReachedResolutionIterationLimit() { + var maxSize = resolutionHost.maxNumberOfFilesToIterateForInvalidation || ts.maxNumberOfFilesToIterateForInvalidation; + return resolvedModuleNames.size > maxSize || resolvedTypeReferenceDirectives.size > maxSize; + } + function invalidateResolutions(isInvalidatedResolution) { + if (hasReachedResolutionIterationLimit()) { + allFilesHaveInvalidatedResolution = true; + return; + } + invalidateResolutionCache(resolvedModuleNames, isInvalidatedResolution, getResolvedModule); + invalidateResolutionCache(resolvedTypeReferenceDirectives, isInvalidatedResolution, getResolvedTypeReferenceDirective); + } + function invalidateResolutionOfFile(filePath) { + removeResolutionsOfFile(filePath); + invalidateResolutions(function (resolution, getResolutionWithResolvedFileName) { + var result = getResolutionWithResolvedFileName(resolution); + return !!result && resolutionHost.toPath(result.resolvedFileName) === filePath; + }); + } + function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) { + ts.Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined); + filesWithInvalidatedNonRelativeUnresolvedImports = filesMap; + } + function invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) { + var isChangedFailedLookupLocation; + if (isCreatingWatchedDirectory) { + isChangedFailedLookupLocation = function (location) { return isInDirectoryPath(fileOrDirectoryPath, resolutionHost.toPath(location)); }; + } + else { + var updatedPath = removeIgnoredPath(fileOrDirectoryPath); + if (!updatedPath) + return false; + fileOrDirectoryPath = updatedPath; + if (resolutionHost.fileIsOpen(fileOrDirectoryPath)) { + return false; + } + var dirOfFileOrDirectory = ts.getDirectoryPath(fileOrDirectoryPath); + if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || isNodeModulesDirectory(fileOrDirectoryPath) || + isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || isNodeModulesDirectory(dirOfFileOrDirectory)) { + isChangedFailedLookupLocation = function (location) { + var locationPath = resolutionHost.toPath(location); + return locationPath === fileOrDirectoryPath || ts.startsWith(resolutionHost.toPath(location), fileOrDirectoryPath); + }; + } + else { + if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) { + return false; + } + if (ts.isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) { + return false; + } + isChangedFailedLookupLocation = function (location) { return resolutionHost.toPath(location) === fileOrDirectoryPath; }; + } + } + var hasChangedFailedLookupLocation = function (resolution) { return ts.some(resolution.failedLookupLocations, isChangedFailedLookupLocation); }; + var invalidatedFilesCount = filesWithInvalidatedResolutions && filesWithInvalidatedResolutions.size; + invalidateResolutions(hasChangedFailedLookupLocation); + return allFilesHaveInvalidatedResolution || filesWithInvalidatedResolutions && filesWithInvalidatedResolutions.size !== invalidatedFilesCount; + } + function closeTypeRootsWatch() { + ts.clearMap(typeRootsWatches, ts.closeFileWatcher); + } + function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath) { + if (allFilesHaveInvalidatedResolution) { + return undefined; + } + if (isInDirectoryPath(rootPath, typeRootPath)) { + return rootPath; + } + var toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath); + return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : undefined; + } + function createTypeRootsWatch(typeRootPath, typeRoot) { + return resolutionHost.watchTypeRootsDirectory(typeRoot, function (fileOrDirectory) { + var fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory); + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + resolutionHost.onChangedAutomaticTypeDirectiveNames(); + var dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath); + if (dirPath && invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath)) { + resolutionHost.onInvalidatedResolution(); + } + }, 1); + } + function updateTypeRootsWatch() { + var options = resolutionHost.getCompilationSettings(); + if (options.types) { + closeTypeRootsWatch(); + return; + } + var typeRoots = ts.getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory: getCurrentDirectory }); + if (typeRoots) { + ts.mutateMap(typeRootsWatches, ts.arrayToMap(typeRoots, function (tr) { return resolutionHost.toPath(tr); }), { + createNewValue: createTypeRootsWatch, + onDeleteValue: ts.closeFileWatcher + }); + } + else { + closeTypeRootsWatch(); + } + } + function directoryExistsForTypeRootWatch(nodeTypesDirectory) { + var dir = ts.getDirectoryPath(ts.getDirectoryPath(nodeTypesDirectory)); + var dirPath = resolutionHost.toPath(dir); + return dirPath === rootPath || canWatchDirectory(dirPath); + } + } + ts.createResolutionCache = createResolutionCache; +})(ts || (ts = {})); +var ts; +(function (ts) { + var moduleSpecifiers; + (function (moduleSpecifiers) { + function getPreferences(_a, compilerOptions, importingSourceFile) { + var importModuleSpecifierPreference = _a.importModuleSpecifierPreference, importModuleSpecifierEnding = _a.importModuleSpecifierEnding; + return { + relativePreference: importModuleSpecifierPreference === "relative" ? 0 : importModuleSpecifierPreference === "non-relative" ? 1 : 2, + ending: getEnding(), + }; + function getEnding() { + switch (importModuleSpecifierEnding) { + case "minimal": return 0; + case "index": return 1; + case "js": return 2; + default: return usesJsExtensionOnImports(importingSourceFile) ? 2 + : ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs ? 1 : 0; + } + } + } + function getPreferencesForUpdate(compilerOptions, oldImportSpecifier) { + return { + relativePreference: ts.isExternalModuleNameRelative(oldImportSpecifier) ? 0 : 1, + ending: ts.hasJSFileExtension(oldImportSpecifier) ? + 2 : + ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs || ts.endsWith(oldImportSpecifier, "index") ? 1 : 0, + }; + } + function updateModuleSpecifier(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, oldImportSpecifier) { + var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, getPreferencesForUpdate(compilerOptions, oldImportSpecifier)); + if (res === oldImportSpecifier) + return undefined; + return res; + } + moduleSpecifiers.updateModuleSpecifier = updateModuleSpecifier; + function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, files, preferences, redirectTargetsMap) { + if (preferences === void 0) { preferences = {}; } + return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, getPreferences(preferences, compilerOptions, importingSourceFile)); + } + moduleSpecifiers.getModuleSpecifier = getModuleSpecifier; + function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host, files, redirectTargetsMap) { + var info = getInfo(importingSourceFileName, host); + var modulePaths = getAllModulePaths(files, importingSourceFileName, nodeModulesFileName, info.getCanonicalFileName, host, redirectTargetsMap); + return ts.firstDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions, true); }); + } + moduleSpecifiers.getNodeModulesPackageName = getNodeModulesPackageName; + function getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, preferences) { + var info = getInfo(importingSourceFileName, host); + var modulePaths = getAllModulePaths(files, importingSourceFileName, toFileName, info.getCanonicalFileName, host, redirectTargetsMap); + return ts.firstDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions); }) || + getLocalModuleSpecifier(toFileName, info, compilerOptions, preferences); + } + function getModuleSpecifiers(moduleSymbol, compilerOptions, importingSourceFile, host, files, userPreferences, redirectTargetsMap) { + var ambient = tryGetModuleNameFromAmbientModule(moduleSymbol); + if (ambient) + return [ambient]; + var info = getInfo(importingSourceFile.path, host); + var moduleSourceFile = ts.getSourceFileOfNode(moduleSymbol.valueDeclaration || ts.getNonAugmentationDeclaration(moduleSymbol)); + var modulePaths = getAllModulePaths(files, importingSourceFile.path, moduleSourceFile.originalFileName, info.getCanonicalFileName, host, redirectTargetsMap); + var preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile); + var global = ts.mapDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions); }); + return global.length ? global : modulePaths.map(function (moduleFileName) { return getLocalModuleSpecifier(moduleFileName, info, compilerOptions, preferences); }); + } + moduleSpecifiers.getModuleSpecifiers = getModuleSpecifiers; + function getInfo(importingSourceFileName, host) { + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true); + var sourceDirectory = ts.getDirectoryPath(importingSourceFileName); + return { getCanonicalFileName: getCanonicalFileName, sourceDirectory: sourceDirectory }; + } + function getLocalModuleSpecifier(moduleFileName, _a, compilerOptions, _b) { + var getCanonicalFileName = _a.getCanonicalFileName, sourceDirectory = _a.sourceDirectory; + var ending = _b.ending, relativePreference = _b.relativePreference; + var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths, rootDirs = compilerOptions.rootDirs; + var relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || + removeExtensionAndIndexPostFix(ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions); + if (!baseUrl || relativePreference === 0) { + return relativePath; + } + var relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseUrl, getCanonicalFileName); + if (!relativeToBaseUrl) { + return relativePath; + } + var importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions); + var fromPaths = paths && tryGetModuleNameFromPaths(ts.removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths); + var nonRelative = fromPaths === undefined ? importRelativeToBaseUrl : fromPaths; + if (relativePreference === 1) { + return nonRelative; + } + if (relativePreference !== 2) + ts.Debug.assertNever(relativePreference); + return isPathRelativeToParent(nonRelative) || countPathComponents(relativePath) < countPathComponents(nonRelative) ? relativePath : nonRelative; + } + function countPathComponents(path) { + var count = 0; + for (var i = ts.startsWith(path, "./") ? 2 : 0; i < path.length; i++) { + if (path.charCodeAt(i) === 47) + count++; + } + return count; + } + moduleSpecifiers.countPathComponents = countPathComponents; + function usesJsExtensionOnImports(_a) { + var imports = _a.imports; + return ts.firstDefined(imports, function (_a) { + var text = _a.text; + return ts.pathIsRelative(text) ? ts.hasJSFileExtension(text) : undefined; + }) || false; + } + function numberOfDirectorySeparators(str) { + var match = str.match(/\//g); + return match ? match.length : 0; + } + function comparePathsByNumberOfDirectorySeparators(a, b) { + return ts.compareValues(numberOfDirectorySeparators(a), numberOfDirectorySeparators(b)); + } + function getAllModulePaths(files, importingFileName, importedFileName, getCanonicalFileName, host, redirectTargetsMap) { + var redirects = redirectTargetsMap.get(importedFileName); + var importedFileNames = redirects ? __spreadArrays(redirects, [importedFileName]) : [importedFileName]; + var cwd = host.getCurrentDirectory ? host.getCurrentDirectory() : ""; + var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); }); + var links = host.getProbableSymlinks + ? host.getProbableSymlinks(files) + : ts.discoverProbableSymlinks(files, getCanonicalFileName, cwd); + var result = []; + var compareStrings = (!host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames()) ? ts.compareStringsCaseSensitive : ts.compareStringsCaseInsensitive; + links.forEach(function (resolved, path) { + if (ts.startsWithDirectory(importingFileName, resolved, getCanonicalFileName)) { + return; + } + var target = ts.find(targets, function (t) { return compareStrings(t.slice(0, resolved.length + 1), resolved + "/") === 0; }); + if (target === undefined) + return; + var relative = ts.getRelativePathFromDirectory(resolved, target, getCanonicalFileName); + var option = ts.resolvePath(path, relative); + if (!host.fileExists || host.fileExists(option)) { + result.push(option); + } + }); + result.push.apply(result, targets); + if (result.length < 2) + return result; + var allFileNames = ts.arrayToMap(result, ts.identity, getCanonicalFileName); + var sortedPaths = []; + var _loop_18 = function (directory) { + var directoryStart = ts.ensureTrailingDirectorySeparator(directory); + var pathsInDirectory; + allFileNames.forEach(function (canonicalFileName, fileName) { + if (ts.startsWith(canonicalFileName, directoryStart)) { + (pathsInDirectory || (pathsInDirectory = [])).push(fileName); + allFileNames.delete(fileName); + } + }); + if (pathsInDirectory) { + if (pathsInDirectory.length > 1) { + pathsInDirectory.sort(comparePathsByNumberOfDirectorySeparators); + } + sortedPaths.push.apply(sortedPaths, pathsInDirectory); + } + var newDirectory = ts.getDirectoryPath(directory); + if (newDirectory === directory) + return out_directory_1 = directory, "break"; + directory = newDirectory; + out_directory_1 = directory; + }; + var out_directory_1; + for (var directory = ts.getDirectoryPath(ts.toPath(importingFileName, cwd, getCanonicalFileName)); allFileNames.size !== 0;) { + var state_7 = _loop_18(directory); + directory = out_directory_1; + if (state_7 === "break") + break; + } + if (allFileNames.size) { + var remainingPaths = ts.arrayFrom(allFileNames.values()); + if (remainingPaths.length > 1) + remainingPaths.sort(comparePathsByNumberOfDirectorySeparators); + sortedPaths.push.apply(sortedPaths, remainingPaths); + } + return sortedPaths; + } + function tryGetModuleNameFromAmbientModule(moduleSymbol) { + var decl = ts.find(moduleSymbol.declarations, function (d) { return ts.isNonGlobalAmbientModule(d) && (!ts.isExternalModuleAugmentation(d) || !ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(d.name))); }); + if (decl) { + return decl.name.text; + } + } + function tryGetModuleNameFromPaths(relativeToBaseUrlWithIndex, relativeToBaseUrl, paths) { + for (var key in paths) { + for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) { + var patternText_1 = _a[_i]; + var pattern = ts.removeFileExtension(ts.normalizePath(patternText_1)); + var indexOfStar = pattern.indexOf("*"); + if (indexOfStar !== -1) { + var prefix = pattern.substr(0, indexOfStar); + var suffix = pattern.substr(indexOfStar + 1); + if (relativeToBaseUrl.length >= prefix.length + suffix.length && + ts.startsWith(relativeToBaseUrl, prefix) && + ts.endsWith(relativeToBaseUrl, suffix) || + !suffix && relativeToBaseUrl === ts.removeTrailingDirectorySeparator(prefix)) { + var matchedStar = relativeToBaseUrl.substr(prefix.length, relativeToBaseUrl.length - suffix.length); + return key.replace("*", matchedStar); + } + } + else if (pattern === relativeToBaseUrl || pattern === relativeToBaseUrlWithIndex) { + return key; + } + } + } + } + function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) { + var normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName); + if (normalizedTargetPath === undefined) { + return undefined; + } + var normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName); + var relativePath = normalizedSourcePath !== undefined ? ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(normalizedSourcePath, normalizedTargetPath, getCanonicalFileName)) : normalizedTargetPath; + return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs + ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions) + : ts.removeFileExtension(relativePath); + } + function tryGetModuleNameAsNodeModule(moduleFileName, _a, host, options, packageNameOnly) { + var getCanonicalFileName = _a.getCanonicalFileName, sourceDirectory = _a.sourceDirectory; + if (!host.fileExists || !host.readFile) { + return undefined; + } + var parts = getNodeModulePathParts(moduleFileName); + if (!parts) { + return undefined; + } + var packageJsonContent; + var packageRootPath = moduleFileName.substring(0, parts.packageRootIndex); + if (!packageNameOnly) { + var packageJsonPath = ts.combinePaths(packageRootPath, "package.json"); + packageJsonContent = host.fileExists(packageJsonPath) + ? JSON.parse(host.readFile(packageJsonPath)) + : undefined; + var versionPaths = packageJsonContent && packageJsonContent.typesVersions + ? ts.getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) + : undefined; + if (versionPaths) { + var subModuleName = moduleFileName.slice(parts.packageRootIndex + 1); + var fromPaths = tryGetModuleNameFromPaths(ts.removeFileExtension(subModuleName), removeExtensionAndIndexPostFix(subModuleName, 0, options), versionPaths.paths); + if (fromPaths !== undefined) { + moduleFileName = ts.combinePaths(moduleFileName.slice(0, parts.packageRootIndex), fromPaths); + } + } + } + var moduleSpecifier = packageNameOnly ? moduleFileName : getDirectoryOrExtensionlessFileName(moduleFileName); + var globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); + var pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); + if (!(ts.startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && ts.startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { + return undefined; + } + var nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); + var packageName = ts.getPackageNameFromTypesPackageName(nodeModulesDirectoryName); + return ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs && packageName === nodeModulesDirectoryName ? undefined : packageName; + function getDirectoryOrExtensionlessFileName(path) { + if (packageJsonContent) { + var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main; + if (ts.isString(mainFileRelative)) { + var mainExportFile = ts.toPath(mainFileRelative, packageRootPath, getCanonicalFileName); + if (ts.removeFileExtension(mainExportFile) === ts.removeFileExtension(getCanonicalFileName(path))) { + return packageRootPath; + } + } + } + var fullModulePathWithoutExtension = ts.removeFileExtension(path); + if (getCanonicalFileName(fullModulePathWithoutExtension.substring(parts.fileNameIndex)) === "/index" && !tryGetAnyFileFromPath(host, fullModulePathWithoutExtension.substring(0, parts.fileNameIndex))) { + return fullModulePathWithoutExtension.substring(0, parts.fileNameIndex); + } + return fullModulePathWithoutExtension; + } + } + function tryGetAnyFileFromPath(host, path) { + if (!host.fileExists) + return; + var extensions = ts.getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 }]); + for (var _i = 0, extensions_3 = extensions; _i < extensions_3.length; _i++) { + var e = extensions_3[_i]; + var fullPath = path + e; + if (host.fileExists(fullPath)) { + return fullPath; + } + } + } + function getNodeModulePathParts(fullPath) { + var topLevelNodeModulesIndex = 0; + var topLevelPackageNameIndex = 0; + var packageRootIndex = 0; + var fileNameIndex = 0; + var partStart = 0; + var partEnd = 0; + var state = 0; + while (partEnd >= 0) { + partStart = partEnd; + partEnd = fullPath.indexOf("/", partStart + 1); + switch (state) { + case 0: + if (fullPath.indexOf(ts.nodeModulesPathPart, partStart) === partStart) { + topLevelNodeModulesIndex = partStart; + topLevelPackageNameIndex = partEnd; + state = 1; + } + break; + case 1: + case 2: + if (state === 1 && fullPath.charAt(partStart + 1) === "@") { + state = 2; + } + else { + packageRootIndex = partEnd; + state = 3; + } + break; + case 3: + if (fullPath.indexOf(ts.nodeModulesPathPart, partStart) === partStart) { + state = 1; + } + else { + state = 3; + } + break; + } + } + fileNameIndex = partStart; + return state > 1 ? { topLevelNodeModulesIndex: topLevelNodeModulesIndex, topLevelPackageNameIndex: topLevelPackageNameIndex, packageRootIndex: packageRootIndex, fileNameIndex: fileNameIndex } : undefined; + } + function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) { + return ts.firstDefined(rootDirs, function (rootDir) { + var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName); + return isPathRelativeToParent(relativePath) ? undefined : relativePath; + }); + } + function removeExtensionAndIndexPostFix(fileName, ending, options) { + if (ts.fileExtensionIs(fileName, ".json")) + return fileName; + var noExtension = ts.removeFileExtension(fileName); + switch (ending) { + case 0: + return ts.removeSuffix(noExtension, "/index"); + case 1: + return noExtension; + case 2: + return noExtension + getJSExtensionForFile(fileName, options); + default: + return ts.Debug.assertNever(ending); + } + } + function getJSExtensionForFile(fileName, options) { + var ext = ts.extensionFromPath(fileName); + switch (ext) { + case ".ts": + case ".d.ts": + return ".js"; + case ".tsx": + return options.jsx === 1 ? ".jsx" : ".js"; + case ".js": + case ".jsx": + case ".json": + return ext; + case ".tsbuildinfo": + return ts.Debug.fail("Extension " + ".tsbuildinfo" + " is unsupported:: FileName:: " + fileName); + default: + return ts.Debug.assertNever(ext); + } + } + function getRelativePathIfInDirectory(path, directoryPath, getCanonicalFileName) { + var relativePath = ts.getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false); + return ts.isRootedDiskPath(relativePath) ? undefined : relativePath; + } + function isPathRelativeToParent(path) { + return ts.startsWith(path, ".."); + } + })(moduleSpecifiers = ts.moduleSpecifiers || (ts.moduleSpecifiers = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var sysFormatDiagnosticsHost = ts.sys ? { + getCurrentDirectory: function () { return ts.sys.getCurrentDirectory(); }, + getNewLine: function () { return ts.sys.newLine; }, + getCanonicalFileName: ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames) + } : undefined; + function createDiagnosticReporter(system, pretty) { + var host = system === ts.sys ? sysFormatDiagnosticsHost : { + getCurrentDirectory: function () { return system.getCurrentDirectory(); }, + getNewLine: function () { return system.newLine; }, + getCanonicalFileName: ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames), + }; + if (!pretty) { + return function (diagnostic) { return system.write(ts.formatDiagnostic(diagnostic, host)); }; + } + var diagnostics = new Array(1); + return function (diagnostic) { + diagnostics[0] = diagnostic; + system.write(ts.formatDiagnosticsWithColorAndContext(diagnostics, host) + host.getNewLine()); + diagnostics[0] = undefined; + }; + } + ts.createDiagnosticReporter = createDiagnosticReporter; + function clearScreenIfNotWatchingForFileChanges(system, diagnostic, options) { + if (system.clearScreen && + !options.preserveWatchOutput && + !options.extendedDiagnostics && + !options.diagnostics && + ts.contains(ts.screenStartingMessageCodes, diagnostic.code)) { + system.clearScreen(); + return true; + } + return false; + } + ts.screenStartingMessageCodes = [ + ts.Diagnostics.Starting_compilation_in_watch_mode.code, + ts.Diagnostics.File_change_detected_Starting_incremental_compilation.code, + ]; + function getPlainDiagnosticFollowingNewLines(diagnostic, newLine) { + return ts.contains(ts.screenStartingMessageCodes, diagnostic.code) + ? newLine + newLine + : newLine; + } + function getLocaleTimeString(system) { + return !system.now ? + new Date().toLocaleTimeString() : + system.now().toLocaleTimeString("en-US", { timeZone: "UTC" }); + } + ts.getLocaleTimeString = getLocaleTimeString; + function createWatchStatusReporter(system, pretty) { + return pretty ? + function (diagnostic, newLine, options) { + clearScreenIfNotWatchingForFileChanges(system, diagnostic, options); + var output = "[" + ts.formatColorAndReset(getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey) + "] "; + output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + (newLine + newLine); + system.write(output); + } : + function (diagnostic, newLine, options) { + var output = ""; + if (!clearScreenIfNotWatchingForFileChanges(system, diagnostic, options)) { + output += newLine; + } + output += getLocaleTimeString(system) + " - "; + output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + getPlainDiagnosticFollowingNewLines(diagnostic, newLine); + system.write(output); + }; + } + ts.createWatchStatusReporter = createWatchStatusReporter; + function parseConfigFileWithSystem(configFileName, optionsToExtend, watchOptionsToExtend, system, reportDiagnostic) { + var host = system; + host.onUnRecoverableConfigFileDiagnostic = function (diagnostic) { return reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic); }; + var result = ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, undefined, watchOptionsToExtend); + host.onUnRecoverableConfigFileDiagnostic = undefined; + return result; + } + ts.parseConfigFileWithSystem = parseConfigFileWithSystem; + function getErrorCountForSummary(diagnostics) { + return ts.countWhere(diagnostics, function (diagnostic) { return diagnostic.category === ts.DiagnosticCategory.Error; }); + } + ts.getErrorCountForSummary = getErrorCountForSummary; + function getWatchErrorSummaryDiagnosticMessage(errorCount) { + return errorCount === 1 ? + ts.Diagnostics.Found_1_error_Watching_for_file_changes : + ts.Diagnostics.Found_0_errors_Watching_for_file_changes; + } + ts.getWatchErrorSummaryDiagnosticMessage = getWatchErrorSummaryDiagnosticMessage; + function getErrorSummaryText(errorCount, newLine) { + if (errorCount === 0) + return ""; + var d = ts.createCompilerDiagnostic(errorCount === 1 ? ts.Diagnostics.Found_1_error : ts.Diagnostics.Found_0_errors, errorCount); + return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine; + } + ts.getErrorSummaryText = getErrorSummaryText; + function listFiles(program, writeFileName) { + if (program.getCompilerOptions().listFiles || program.getCompilerOptions().listFilesOnly) { + ts.forEach(program.getSourceFiles(), function (file) { + writeFileName(file.fileName); + }); + } + } + ts.listFiles = listFiles; + function emitFilesAndReportErrors(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var isListFilesOnly = !!program.getCompilerOptions().listFilesOnly; + var allDiagnostics = program.getConfigFileParsingDiagnostics().slice(); + var configFileParsingDiagnosticsLength = allDiagnostics.length; + ts.addRange(allDiagnostics, program.getSyntacticDiagnostics(undefined, cancellationToken)); + if (allDiagnostics.length === configFileParsingDiagnosticsLength) { + ts.addRange(allDiagnostics, program.getOptionsDiagnostics(cancellationToken)); + if (!isListFilesOnly) { + ts.addRange(allDiagnostics, program.getGlobalDiagnostics(cancellationToken)); + if (allDiagnostics.length === configFileParsingDiagnosticsLength) { + ts.addRange(allDiagnostics, program.getSemanticDiagnostics(undefined, cancellationToken)); + } + } + } + var emitResult = isListFilesOnly + ? { emitSkipped: true, diagnostics: ts.emptyArray } + : program.emit(undefined, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers); + var emittedFiles = emitResult.emittedFiles, emitDiagnostics = emitResult.diagnostics; + ts.addRange(allDiagnostics, emitDiagnostics); + var diagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics); + diagnostics.forEach(reportDiagnostic); + if (writeFileName) { + var currentDir_1 = program.getCurrentDirectory(); + ts.forEach(emittedFiles, function (file) { + var filepath = ts.getNormalizedAbsolutePath(file, currentDir_1); + writeFileName("TSFILE: " + filepath); + }); + listFiles(program, writeFileName); + } + if (reportSummary) { + reportSummary(getErrorCountForSummary(diagnostics)); + } + return { + emitResult: emitResult, + diagnostics: diagnostics, + }; + } + ts.emitFilesAndReportErrors = emitFilesAndReportErrors; + function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var _a = emitFilesAndReportErrors(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers), emitResult = _a.emitResult, diagnostics = _a.diagnostics; + if (emitResult.emitSkipped && diagnostics.length > 0) { + return ts.ExitStatus.DiagnosticsPresent_OutputsSkipped; + } + else if (diagnostics.length > 0) { + return ts.ExitStatus.DiagnosticsPresent_OutputsGenerated; + } + return ts.ExitStatus.Success; + } + ts.emitFilesAndReportErrorsAndGetExitStatus = emitFilesAndReportErrorsAndGetExitStatus; + ts.noopFileWatcher = { close: ts.noop }; + function createWatchHost(system, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var onWatchStatusChange = reportWatchStatus || createWatchStatusReporter(system); + return { + onWatchStatusChange: onWatchStatusChange, + watchFile: ts.maybeBind(system, system.watchFile) || (function () { return ts.noopFileWatcher; }), + watchDirectory: ts.maybeBind(system, system.watchDirectory) || (function () { return ts.noopFileWatcher; }), + setTimeout: ts.maybeBind(system, system.setTimeout) || ts.noop, + clearTimeout: ts.maybeBind(system, system.clearTimeout) || ts.noop + }; + } + ts.createWatchHost = createWatchHost; + ts.WatchType = { + ConfigFile: "Config file", + SourceFile: "Source file", + MissingFile: "Missing file", + WildcardDirectory: "Wild card directory", + FailedLookupLocations: "Failed Lookup Locations", + TypeRoots: "Type roots" + }; + function createWatchFactory(host, options) { + var watchLogLevel = host.trace ? options.extendedDiagnostics ? ts.WatchLogLevel.Verbose : options.diagnostics ? ts.WatchLogLevel.TriggerOnly : ts.WatchLogLevel.None : ts.WatchLogLevel.None; + var writeLog = watchLogLevel !== ts.WatchLogLevel.None ? (function (s) { return host.trace(s); }) : ts.noop; + var result = ts.getWatchFactory(watchLogLevel, writeLog); + result.writeLog = writeLog; + return result; + } + ts.createWatchFactory = createWatchFactory; + function createCompilerHostFromProgramHost(host, getCompilerOptions, directoryStructureHost) { + if (directoryStructureHost === void 0) { directoryStructureHost = host; } + var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames(); + var hostGetNewLine = ts.memoize(function () { return host.getNewLine(); }); + return { + getSourceFile: function (fileName, languageVersion, onError) { + var text; + try { + ts.performance.mark("beforeIORead"); + text = host.readFile(fileName, getCompilerOptions().charset); + ts.performance.mark("afterIORead"); + ts.performance.measure("I/O Read", "beforeIORead", "afterIORead"); + } + catch (e) { + if (onError) { + onError(e.message); + } + text = ""; + } + return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion) : undefined; + }, + getDefaultLibLocation: ts.maybeBind(host, host.getDefaultLibLocation), + getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); }, + writeFile: writeFile, + getCurrentDirectory: ts.memoize(function () { return host.getCurrentDirectory(); }), + useCaseSensitiveFileNames: function () { return useCaseSensitiveFileNames; }, + getCanonicalFileName: ts.createGetCanonicalFileName(useCaseSensitiveFileNames), + getNewLine: function () { return ts.getNewLineCharacter(getCompilerOptions(), hostGetNewLine); }, + fileExists: function (f) { return host.fileExists(f); }, + readFile: function (f) { return host.readFile(f); }, + trace: ts.maybeBind(host, host.trace), + directoryExists: ts.maybeBind(directoryStructureHost, directoryStructureHost.directoryExists), + getDirectories: ts.maybeBind(directoryStructureHost, directoryStructureHost.getDirectories), + realpath: ts.maybeBind(host, host.realpath), + getEnvironmentVariable: ts.maybeBind(host, host.getEnvironmentVariable) || (function () { return ""; }), + createHash: ts.maybeBind(host, host.createHash), + readDirectory: ts.maybeBind(host, host.readDirectory), + }; + function writeFile(fileName, text, writeByteOrderMark, onError) { + try { + ts.performance.mark("beforeIOWrite"); + ts.writeFileEnsuringDirectories(fileName, text, writeByteOrderMark, function (path, data, writeByteOrderMark) { return host.writeFile(path, data, writeByteOrderMark); }, function (path) { return host.createDirectory(path); }, function (path) { return host.directoryExists(path); }); + ts.performance.mark("afterIOWrite"); + ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite"); + } + catch (e) { + if (onError) { + onError(e.message); + } + } + } + } + ts.createCompilerHostFromProgramHost = createCompilerHostFromProgramHost; + function setGetSourceFileAsHashVersioned(compilerHost, host) { + var originalGetSourceFile = compilerHost.getSourceFile; + var computeHash = host.createHash || ts.generateDjb2Hash; + compilerHost.getSourceFile = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var result = originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArrays([compilerHost], args)); + if (result) { + result.version = computeHash.call(host, result.text); + } + return result; + }; + } + ts.setGetSourceFileAsHashVersioned = setGetSourceFileAsHashVersioned; + function createProgramHost(system, createProgram) { + var getDefaultLibLocation = ts.memoize(function () { return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath())); }); + var host = system; + host; + return { + useCaseSensitiveFileNames: function () { return system.useCaseSensitiveFileNames; }, + getNewLine: function () { return system.newLine; }, + getCurrentDirectory: ts.memoize(function () { return system.getCurrentDirectory(); }), + getDefaultLibLocation: getDefaultLibLocation, + getDefaultLibFileName: function (options) { return ts.combinePaths(getDefaultLibLocation(), ts.getDefaultLibFileName(options)); }, + fileExists: function (path) { return system.fileExists(path); }, + readFile: function (path, encoding) { return system.readFile(path, encoding); }, + directoryExists: function (path) { return system.directoryExists(path); }, + getDirectories: function (path) { return system.getDirectories(path); }, + readDirectory: function (path, extensions, exclude, include, depth) { return system.readDirectory(path, extensions, exclude, include, depth); }, + realpath: ts.maybeBind(system, system.realpath), + getEnvironmentVariable: ts.maybeBind(system, system.getEnvironmentVariable), + trace: function (s) { return system.write(s + system.newLine); }, + createDirectory: function (path) { return system.createDirectory(path); }, + writeFile: function (path, data, writeByteOrderMark) { return system.writeFile(path, data, writeByteOrderMark); }, + onCachedDirectoryStructureHostCreate: function (cacheHost) { return host = cacheHost || system; }, + createHash: ts.maybeBind(system, system.createHash), + createProgram: createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram + }; + } + ts.createProgramHost = createProgramHost; + function createWatchCompilerHost(system, createProgram, reportDiagnostic, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var writeFileName = function (s) { return system.write(s + system.newLine); }; + var result = createProgramHost(system, createProgram); + ts.copyProperties(result, createWatchHost(system, reportWatchStatus)); + result.afterProgramCreate = function (builderProgram) { + var compilerOptions = builderProgram.getCompilerOptions(); + var newLine = ts.getNewLineCharacter(compilerOptions, function () { return system.newLine; }); + emitFilesAndReportErrors(builderProgram, reportDiagnostic, writeFileName, function (errorCount) { return result.onWatchStatusChange(ts.createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount), newLine, compilerOptions, errorCount); }); + }; + return result; + } + function reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic) { + reportDiagnostic(diagnostic); + system.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + function createWatchCompilerHostOfConfigFile(configFileName, optionsToExtend, watchOptionsToExtend, system, createProgram, reportDiagnostic, reportWatchStatus) { + var diagnosticReporter = reportDiagnostic || createDiagnosticReporter(system); + var host = createWatchCompilerHost(system, createProgram, diagnosticReporter, reportWatchStatus); + host.onUnRecoverableConfigFileDiagnostic = function (diagnostic) { return reportUnrecoverableDiagnostic(system, diagnosticReporter, diagnostic); }; + host.configFileName = configFileName; + host.optionsToExtend = optionsToExtend; + host.watchOptionsToExtend = watchOptionsToExtend; + return host; + } + ts.createWatchCompilerHostOfConfigFile = createWatchCompilerHostOfConfigFile; + function createWatchCompilerHostOfFilesAndCompilerOptions(rootFiles, options, watchOptions, system, createProgram, reportDiagnostic, reportWatchStatus, projectReferences) { + var host = createWatchCompilerHost(system, createProgram, reportDiagnostic || createDiagnosticReporter(system), reportWatchStatus); + host.rootFiles = rootFiles; + host.options = options; + host.watchOptions = watchOptions; + host.projectReferences = projectReferences; + return host; + } + ts.createWatchCompilerHostOfFilesAndCompilerOptions = createWatchCompilerHostOfFilesAndCompilerOptions; + function performIncrementalCompilation(input) { + var system = input.system || ts.sys; + var host = input.host || (input.host = ts.createIncrementalCompilerHost(input.options, system)); + var builderProgram = ts.createIncrementalProgram(input); + var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount) { return system.write(getErrorSummaryText(errorCount, system.newLine)); } : undefined); + if (input.afterProgramEmitAndDiagnostics) + input.afterProgramEmitAndDiagnostics(builderProgram); + return exitStatus; + } + ts.performIncrementalCompilation = performIncrementalCompilation; +})(ts || (ts = {})); +var ts; +(function (ts) { + function readBuilderProgram(compilerOptions, host) { + if (compilerOptions.out || compilerOptions.outFile) + return undefined; + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions); + if (!buildInfoPath) + return undefined; + var content = host.readFile(buildInfoPath); + if (!content) + return undefined; + var buildInfo = ts.getBuildInfo(content); + if (buildInfo.version !== ts.version) + return undefined; + if (!buildInfo.program) + return undefined; + return ts.createBuildProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host); + } + ts.readBuilderProgram = readBuilderProgram; + function createIncrementalCompilerHost(options, system) { + if (system === void 0) { system = ts.sys; } + var host = ts.createCompilerHostWorker(options, undefined, system); + host.createHash = ts.maybeBind(system, system.createHash); + ts.setGetSourceFileAsHashVersioned(host, system); + ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); }); + return host; + } + ts.createIncrementalCompilerHost = createIncrementalCompilerHost; + function createIncrementalProgram(_a) { + var rootNames = _a.rootNames, options = _a.options, configFileParsingDiagnostics = _a.configFileParsingDiagnostics, projectReferences = _a.projectReferences, host = _a.host, createProgram = _a.createProgram; + host = host || createIncrementalCompilerHost(options); + createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram; + var oldProgram = readBuilderProgram(options, host); + return createProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences); + } + ts.createIncrementalProgram = createIncrementalProgram; + function createWatchCompilerHost(rootFilesOrConfigFileName, options, system, createProgram, reportDiagnostic, reportWatchStatus, projectReferencesOrWatchOptionsToExtend, watchOptions) { + if (ts.isArray(rootFilesOrConfigFileName)) { + return ts.createWatchCompilerHostOfFilesAndCompilerOptions(rootFilesOrConfigFileName, options, watchOptions, system, createProgram, reportDiagnostic, reportWatchStatus, projectReferencesOrWatchOptionsToExtend); + } + else { + return ts.createWatchCompilerHostOfConfigFile(rootFilesOrConfigFileName, options, projectReferencesOrWatchOptionsToExtend, system, createProgram, reportDiagnostic, reportWatchStatus); + } + } + ts.createWatchCompilerHost = createWatchCompilerHost; + function createWatchProgram(host) { + var builderProgram; + var reloadLevel; + var missingFilesMap; + var watchedWildcardDirectories; + var timerToUpdateProgram; + var sourceFilesCache = ts.createMap(); + var missingFilePathsRequestedForRelease; + var hasChangedCompilerOptions = false; + var hasChangedAutomaticTypeDirectiveNames = false; + var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames(); + var currentDirectory = host.getCurrentDirectory(); + var configFileName = host.configFileName, _a = host.optionsToExtend, optionsToExtendForConfigFile = _a === void 0 ? {} : _a, watchOptionsToExtend = host.watchOptionsToExtend, createProgram = host.createProgram; + var rootFileNames = host.rootFiles, compilerOptions = host.options, watchOptions = host.watchOptions, projectReferences = host.projectReferences; + var configFileSpecs; + var configFileParsingDiagnostics; + var canConfigFileJsonReportNoInputFiles = false; + var hasChangedConfigFileParsingErrors = false; + var cachedDirectoryStructureHost = configFileName === undefined ? undefined : ts.createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames); + if (cachedDirectoryStructureHost && host.onCachedDirectoryStructureHostCreate) { + host.onCachedDirectoryStructureHostCreate(cachedDirectoryStructureHost); + } + var directoryStructureHost = cachedDirectoryStructureHost || host; + var parseConfigFileHost = ts.parseConfigHostFromCompilerHostLike(host, directoryStructureHost); + var newLine = updateNewLine(); + if (configFileName && host.configFileParsingResult) { + setConfigFileParsingResult(host.configFileParsingResult); + newLine = updateNewLine(); + } + reportWatchDiagnostic(ts.Diagnostics.Starting_compilation_in_watch_mode); + if (configFileName && !host.configFileParsingResult) { + newLine = ts.getNewLineCharacter(optionsToExtendForConfigFile, function () { return host.getNewLine(); }); + ts.Debug.assert(!rootFileNames); + parseConfigFile(); + newLine = updateNewLine(); + } + var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchFilePath = _b.watchFilePath, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog; + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + writeLog("Current directory: " + currentDirectory + " CaseSensitiveFileNames: " + useCaseSensitiveFileNames); + var configFileWatcher; + if (configFileName) { + configFileWatcher = watchFile(host, configFileName, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ConfigFile); + } + var compilerHost = ts.createCompilerHostFromProgramHost(host, function () { return compilerOptions; }, directoryStructureHost); + ts.setGetSourceFileAsHashVersioned(compilerHost, host); + var getNewSourceFile = compilerHost.getSourceFile; + compilerHost.getSourceFile = function (fileName) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return getVersionedSourceFileByPath.apply(void 0, __spreadArrays([fileName, toPath(fileName)], args)); + }; + compilerHost.getSourceFileByPath = getVersionedSourceFileByPath; + compilerHost.getNewLine = function () { return newLine; }; + compilerHost.fileExists = fileExists; + compilerHost.onReleaseOldSourceFile = onReleaseOldSourceFile; + compilerHost.toPath = toPath; + compilerHost.getCompilationSettings = function () { return compilerOptions; }; + compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); }; + compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); }; + compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; }; + compilerHost.onInvalidatedResolution = scheduleProgramUpdate; + compilerHost.onChangedAutomaticTypeDirectiveNames = function () { + hasChangedAutomaticTypeDirectiveNames = true; + scheduleProgramUpdate(); + }; + compilerHost.fileIsOpen = ts.returnFalse; + compilerHost.maxNumberOfFilesToIterateForInvalidation = host.maxNumberOfFilesToIterateForInvalidation; + compilerHost.getCurrentProgram = getCurrentProgram; + compilerHost.writeLog = writeLog; + var resolutionCache = ts.createResolutionCache(compilerHost, configFileName ? + ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFileName, currentDirectory)) : + currentDirectory, false); + compilerHost.resolveModuleNames = host.resolveModuleNames ? + (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return host.resolveModuleNames.apply(host, args); + }) : + (function (moduleNames, containingFile, reusedNames, redirectedReference) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference); }); + compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? + (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return host.resolveTypeReferenceDirectives.apply(host, args); + }) : + (function (typeDirectiveNames, containingFile, redirectedReference) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference); }); + var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives; + builderProgram = readBuilderProgram(compilerOptions, compilerHost); + synchronizeProgram(); + watchConfigFileWildCardDirectories(); + return configFileName ? + { getCurrentProgram: getCurrentBuilderProgram, getProgram: synchronizeProgram, close: close } : + { getCurrentProgram: getCurrentBuilderProgram, getProgram: synchronizeProgram, updateRootFileNames: updateRootFileNames, close: close }; + function close() { + resolutionCache.clear(); + ts.clearMap(sourceFilesCache, function (value) { + if (value && value.fileWatcher) { + value.fileWatcher.close(); + value.fileWatcher = undefined; + } + }); + if (configFileWatcher) { + configFileWatcher.close(); + configFileWatcher = undefined; + } + if (watchedWildcardDirectories) { + ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); + watchedWildcardDirectories = undefined; + } + if (missingFilesMap) { + ts.clearMap(missingFilesMap, ts.closeFileWatcher); + missingFilesMap = undefined; + } + } + function getCurrentBuilderProgram() { + return builderProgram; + } + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } + function synchronizeProgram() { + writeLog("Synchronizing program"); + var program = getCurrentBuilderProgram(); + if (hasChangedCompilerOptions) { + newLine = updateNewLine(); + if (program && ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) { + resolutionCache.clear(); + } + } + var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution); + if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, projectReferences)) { + if (hasChangedConfigFileParsingErrors) { + builderProgram = createProgram(undefined, undefined, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences); + hasChangedConfigFileParsingErrors = false; + } + } + else { + createNewProgram(hasInvalidatedResolution); + } + if (host.afterProgramCreate) { + host.afterProgramCreate(builderProgram); + } + return builderProgram; + } + function createNewProgram(hasInvalidatedResolution) { + writeLog("CreatingProgramWith::"); + writeLog(" roots: " + JSON.stringify(rootFileNames)); + writeLog(" options: " + JSON.stringify(compilerOptions)); + var needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram(); + hasChangedCompilerOptions = false; + hasChangedConfigFileParsingErrors = false; + resolutionCache.startCachingPerDirectoryResolution(); + compilerHost.hasInvalidatedResolution = hasInvalidatedResolution; + compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames; + builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences); + resolutionCache.finishCachingPerDirectoryResolution(); + ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = ts.createMap()), watchMissingFilePath); + if (needsUpdateInTypeRootWatch) { + resolutionCache.updateTypeRootsWatch(); + } + if (missingFilePathsRequestedForRelease) { + for (var _i = 0, missingFilePathsRequestedForRelease_1 = missingFilePathsRequestedForRelease; _i < missingFilePathsRequestedForRelease_1.length; _i++) { + var missingFilePath = missingFilePathsRequestedForRelease_1[_i]; + if (!missingFilesMap.has(missingFilePath)) { + sourceFilesCache.delete(missingFilePath); + } + } + missingFilePathsRequestedForRelease = undefined; + } + } + function updateRootFileNames(files) { + ts.Debug.assert(!configFileName, "Cannot update root file names with config file watch mode"); + rootFileNames = files; + scheduleProgramUpdate(); + } + function updateNewLine() { + return ts.getNewLineCharacter(compilerOptions || optionsToExtendForConfigFile, function () { return host.getNewLine(); }); + } + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function isFileMissingOnHost(hostSourceFile) { + return typeof hostSourceFile === "boolean"; + } + function isFilePresenceUnknownOnHost(hostSourceFile) { + return typeof hostSourceFile.version === "boolean"; + } + function fileExists(fileName) { + var path = toPath(fileName); + if (isFileMissingOnHost(sourceFilesCache.get(path))) { + return true; + } + return directoryStructureHost.fileExists(fileName); + } + function getVersionedSourceFileByPath(fileName, path, languageVersion, onError, shouldCreateNewSourceFile) { + var hostSourceFile = sourceFilesCache.get(path); + if (isFileMissingOnHost(hostSourceFile)) { + return undefined; + } + if (hostSourceFile === undefined || shouldCreateNewSourceFile || isFilePresenceUnknownOnHost(hostSourceFile)) { + var sourceFile = getNewSourceFile(fileName, languageVersion, onError); + if (hostSourceFile) { + if (sourceFile) { + hostSourceFile.sourceFile = sourceFile; + hostSourceFile.version = sourceFile.version; + if (!hostSourceFile.fileWatcher) { + hostSourceFile.fileWatcher = watchFilePath(host, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, path, ts.WatchType.SourceFile); + } + } + else { + if (hostSourceFile.fileWatcher) { + hostSourceFile.fileWatcher.close(); + } + sourceFilesCache.set(path, false); + } + } + else { + if (sourceFile) { + var fileWatcher = watchFilePath(host, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, path, ts.WatchType.SourceFile); + sourceFilesCache.set(path, { sourceFile: sourceFile, version: sourceFile.version, fileWatcher: fileWatcher }); + } + else { + sourceFilesCache.set(path, false); + } + } + return sourceFile; + } + return hostSourceFile.sourceFile; + } + function nextSourceFileVersion(path) { + var hostSourceFile = sourceFilesCache.get(path); + if (hostSourceFile !== undefined) { + if (isFileMissingOnHost(hostSourceFile)) { + sourceFilesCache.set(path, { version: false }); + } + else { + hostSourceFile.version = false; + } + } + } + function getSourceVersion(path) { + var hostSourceFile = sourceFilesCache.get(path); + return !hostSourceFile || !hostSourceFile.version ? undefined : hostSourceFile.version; + } + function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) { + var hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath); + if (hostSourceFileInfo !== undefined) { + if (isFileMissingOnHost(hostSourceFileInfo)) { + (missingFilePathsRequestedForRelease || (missingFilePathsRequestedForRelease = [])).push(oldSourceFile.path); + } + else if (hostSourceFileInfo.sourceFile === oldSourceFile) { + if (hostSourceFileInfo.fileWatcher) { + hostSourceFileInfo.fileWatcher.close(); + } + sourceFilesCache.delete(oldSourceFile.resolvedPath); + if (!hasSourceFileByPath) { + resolutionCache.removeResolutionsOfFile(oldSourceFile.path); + } + } + } + } + function reportWatchDiagnostic(message) { + if (host.onWatchStatusChange) { + host.onWatchStatusChange(ts.createCompilerDiagnostic(message), newLine, compilerOptions || optionsToExtendForConfigFile); + } + } + function scheduleProgramUpdate() { + if (!host.setTimeout || !host.clearTimeout) { + return; + } + if (timerToUpdateProgram) { + host.clearTimeout(timerToUpdateProgram); + } + writeLog("Scheduling update"); + timerToUpdateProgram = host.setTimeout(updateProgram, 250); + } + function scheduleProgramReload() { + ts.Debug.assert(!!configFileName); + reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + scheduleProgramUpdate(); + } + function updateProgram() { + timerToUpdateProgram = undefined; + reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation); + switch (reloadLevel) { + case ts.ConfigFileProgramReloadLevel.Partial: + ts.perfLogger.logStartUpdateProgram("PartialConfigReload"); + reloadFileNamesFromConfigFile(); + break; + case ts.ConfigFileProgramReloadLevel.Full: + ts.perfLogger.logStartUpdateProgram("FullConfigReload"); + reloadConfigFile(); + break; + default: + ts.perfLogger.logStartUpdateProgram("SynchronizeProgram"); + synchronizeProgram(); + break; + } + ts.perfLogger.logStopUpdateProgram("Done"); + } + function reloadFileNamesFromConfigFile() { + writeLog("Reloading new file names and options"); + var result = ts.getFileNamesFromConfigSpecs(configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost); + if (ts.updateErrorForNoInputFiles(result, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) { + hasChangedConfigFileParsingErrors = true; + } + rootFileNames = result.fileNames; + synchronizeProgram(); + } + function reloadConfigFile() { + writeLog("Reloading config file: " + configFileName); + reloadLevel = ts.ConfigFileProgramReloadLevel.None; + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.clearCache(); + } + parseConfigFile(); + hasChangedCompilerOptions = true; + synchronizeProgram(); + watchConfigFileWildCardDirectories(); + } + function parseConfigFile() { + setConfigFileParsingResult(ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtendForConfigFile, parseConfigFileHost, undefined, watchOptionsToExtend)); + } + function setConfigFileParsingResult(configFileParseResult) { + rootFileNames = configFileParseResult.fileNames; + compilerOptions = configFileParseResult.options; + watchOptions = configFileParseResult.watchOptions; + configFileSpecs = configFileParseResult.configFileSpecs; + projectReferences = configFileParseResult.projectReferences; + configFileParsingDiagnostics = ts.getConfigFileParsingDiagnostics(configFileParseResult).slice(); + canConfigFileJsonReportNoInputFiles = ts.canJsonReportNoInutFiles(configFileParseResult.raw); + hasChangedConfigFileParsingErrors = true; + } + function onSourceFileChange(fileName, eventKind, path) { + updateCachedSystemWithFile(fileName, path, eventKind); + if (eventKind === ts.FileWatcherEventKind.Deleted && sourceFilesCache.has(path)) { + resolutionCache.invalidateResolutionOfFile(path); + } + resolutionCache.removeResolutionsFromProjectReferenceRedirects(path); + nextSourceFileVersion(path); + scheduleProgramUpdate(); + } + function updateCachedSystemWithFile(fileName, path, eventKind) { + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind); + } + } + function watchMissingFilePath(missingFilePath) { + return watchFilePath(host, missingFilePath, onMissingFileChange, ts.PollingInterval.Medium, watchOptions, missingFilePath, ts.WatchType.MissingFile); + } + function onMissingFileChange(fileName, eventKind, missingFilePath) { + updateCachedSystemWithFile(fileName, missingFilePath, eventKind); + if (eventKind === ts.FileWatcherEventKind.Created && missingFilesMap.has(missingFilePath)) { + missingFilesMap.get(missingFilePath).close(); + missingFilesMap.delete(missingFilePath); + nextSourceFileVersion(missingFilePath); + scheduleProgramUpdate(); + } + } + function watchConfigFileWildCardDirectories() { + if (configFileSpecs) { + ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = ts.createMap()), ts.createMapFromTemplate(configFileSpecs.wildcardDirectories), watchWildcardDirectory); + } + else if (watchedWildcardDirectories) { + ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); + } + } + function watchWildcardDirectory(directory, flags) { + return watchDirectory(host, directory, function (fileOrDirectory) { + ts.Debug.assert(!!configFileName); + var fileOrDirectoryPath = toPath(fileOrDirectory); + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + nextSourceFileVersion(fileOrDirectoryPath); + fileOrDirectoryPath = ts.removeIgnoredPath(fileOrDirectoryPath); + if (!fileOrDirectoryPath) + return; + if (fileOrDirectoryPath !== directory && ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, compilerOptions)) { + writeLog("Project: " + configFileName + " Detected file add/remove of non supported extension: " + fileOrDirectory); + return; + } + if (reloadLevel !== ts.ConfigFileProgramReloadLevel.Full) { + reloadLevel = ts.ConfigFileProgramReloadLevel.Partial; + scheduleProgramUpdate(); + } + }, flags, watchOptions, ts.WatchType.WildcardDirectory); + } + } + ts.createWatchProgram = createWatchProgram; +})(ts || (ts = {})); +var ts; +(function (ts) { + var UpToDateStatusType; + (function (UpToDateStatusType) { + UpToDateStatusType[UpToDateStatusType["Unbuildable"] = 0] = "Unbuildable"; + UpToDateStatusType[UpToDateStatusType["UpToDate"] = 1] = "UpToDate"; + UpToDateStatusType[UpToDateStatusType["UpToDateWithUpstreamTypes"] = 2] = "UpToDateWithUpstreamTypes"; + UpToDateStatusType[UpToDateStatusType["OutOfDateWithPrepend"] = 3] = "OutOfDateWithPrepend"; + UpToDateStatusType[UpToDateStatusType["OutputMissing"] = 4] = "OutputMissing"; + UpToDateStatusType[UpToDateStatusType["OutOfDateWithSelf"] = 5] = "OutOfDateWithSelf"; + UpToDateStatusType[UpToDateStatusType["OutOfDateWithUpstream"] = 6] = "OutOfDateWithUpstream"; + UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 7] = "UpstreamOutOfDate"; + UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 8] = "UpstreamBlocked"; + UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 9] = "ComputingUpstream"; + UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 10] = "TsVersionOutputOfDate"; + UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 11] = "ContainerOnly"; + })(UpToDateStatusType = ts.UpToDateStatusType || (ts.UpToDateStatusType = {})); + function resolveConfigFileProjectName(project) { + if (ts.fileExtensionIs(project, ".json")) { + return project; + } + return ts.combinePaths(project, "tsconfig.json"); + } + ts.resolveConfigFileProjectName = resolveConfigFileProjectName; +})(ts || (ts = {})); +var ts; +(function (ts) { + var minimumDate = new Date(-8640000000000000); + var maximumDate = new Date(8640000000000000); + var BuildResultFlags; + (function (BuildResultFlags) { + BuildResultFlags[BuildResultFlags["None"] = 0] = "None"; + BuildResultFlags[BuildResultFlags["Success"] = 1] = "Success"; + BuildResultFlags[BuildResultFlags["DeclarationOutputUnchanged"] = 2] = "DeclarationOutputUnchanged"; + BuildResultFlags[BuildResultFlags["ConfigFileErrors"] = 4] = "ConfigFileErrors"; + BuildResultFlags[BuildResultFlags["SyntaxErrors"] = 8] = "SyntaxErrors"; + BuildResultFlags[BuildResultFlags["TypeErrors"] = 16] = "TypeErrors"; + BuildResultFlags[BuildResultFlags["DeclarationEmitErrors"] = 32] = "DeclarationEmitErrors"; + BuildResultFlags[BuildResultFlags["EmitErrors"] = 64] = "EmitErrors"; + BuildResultFlags[BuildResultFlags["AnyErrors"] = 124] = "AnyErrors"; + })(BuildResultFlags || (BuildResultFlags = {})); + function createConfigFileMap() { + return ts.createMap(); + } + function getOrCreateValueFromConfigFileMap(configFileMap, resolved, createT) { + var existingValue = configFileMap.get(resolved); + var newValue; + if (!existingValue) { + newValue = createT(); + configFileMap.set(resolved, newValue); + } + return existingValue || newValue; + } + function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) { + return getOrCreateValueFromConfigFileMap(configFileMap, resolved, ts.createMap); + } + function newer(date1, date2) { + return date2 > date1 ? date2 : date1; + } + function isDeclarationFile(fileName) { + return ts.fileExtensionIs(fileName, ".d.ts"); + } + function isCircularBuildOrder(buildOrder) { + return !!buildOrder && !!buildOrder.buildOrder; + } + ts.isCircularBuildOrder = isCircularBuildOrder; + function getBuildOrderFromAnyBuildOrder(anyBuildOrder) { + return isCircularBuildOrder(anyBuildOrder) ? anyBuildOrder.buildOrder : anyBuildOrder; + } + ts.getBuildOrderFromAnyBuildOrder = getBuildOrderFromAnyBuildOrder; + function createBuilderStatusReporter(system, pretty) { + return function (diagnostic) { + var output = pretty ? "[" + ts.formatColorAndReset(ts.getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey) + "] " : ts.getLocaleTimeString(system) + " - "; + output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + (system.newLine + system.newLine); + system.write(output); + }; + } + ts.createBuilderStatusReporter = createBuilderStatusReporter; + function createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus) { + var host = ts.createProgramHost(system, createProgram); + host.getModifiedTime = system.getModifiedTime ? function (path) { return system.getModifiedTime(path); } : ts.returnUndefined; + host.setModifiedTime = system.setModifiedTime ? function (path, date) { return system.setModifiedTime(path, date); } : ts.noop; + host.deleteFile = system.deleteFile ? function (path) { return system.deleteFile(path); } : ts.noop; + host.reportDiagnostic = reportDiagnostic || ts.createDiagnosticReporter(system); + host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system); + host.now = ts.maybeBind(system, system.now); + return host; + } + function createSolutionBuilderHost(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus, reportErrorSummary) { + if (system === void 0) { system = ts.sys; } + var host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus); + host.reportErrorSummary = reportErrorSummary; + return host; + } + ts.createSolutionBuilderHost = createSolutionBuilderHost; + function createSolutionBuilderWithWatchHost(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus); + var watchHost = ts.createWatchHost(system, reportWatchStatus); + ts.copyProperties(host, watchHost); + return host; + } + ts.createSolutionBuilderWithWatchHost = createSolutionBuilderWithWatchHost; + function getCompilerOptionsOfBuildOptions(buildOptions) { + var result = {}; + ts.commonOptionsWithBuild.forEach(function (option) { + if (ts.hasProperty(buildOptions, option.name)) + result[option.name] = buildOptions[option.name]; + }); + return result; + } + function createSolutionBuilder(host, rootNames, defaultOptions) { + return createSolutionBuilderWorker(false, host, rootNames, defaultOptions); + } + ts.createSolutionBuilder = createSolutionBuilder; + function createSolutionBuilderWithWatch(host, rootNames, defaultOptions, baseWatchOptions) { + return createSolutionBuilderWorker(true, host, rootNames, defaultOptions, baseWatchOptions); + } + ts.createSolutionBuilderWithWatch = createSolutionBuilderWithWatch; + function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) { + var host = hostOrHostWithWatch; + var hostWithWatch = hostOrHostWithWatch; + var currentDirectory = host.getCurrentDirectory(); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var baseCompilerOptions = getCompilerOptionsOfBuildOptions(options); + var compilerHost = ts.createCompilerHostFromProgramHost(host, function () { return state.projectCompilerOptions; }); + ts.setGetSourceFileAsHashVersioned(compilerHost, host); + compilerHost.getParsedCommandLine = function (fileName) { return parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName)); }; + compilerHost.resolveModuleNames = ts.maybeBind(host, host.resolveModuleNames); + compilerHost.resolveTypeReferenceDirectives = ts.maybeBind(host, host.resolveTypeReferenceDirectives); + var moduleResolutionCache = !compilerHost.resolveModuleNames ? ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined; + if (!compilerHost.resolveModuleNames) { + var loader_3 = function (moduleName, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference).resolvedModule; }; + compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference) { + return ts.loadWithLocalCache(ts.Debug.assertEachDefined(moduleNames), containingFile, redirectedReference, loader_3); + }; + } + var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchFilePath = _a.watchFilePath, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog; + var state = { + host: host, + hostWithWatch: hostWithWatch, + currentDirectory: currentDirectory, + getCanonicalFileName: getCanonicalFileName, + parseConfigFileHost: ts.parseConfigHostFromCompilerHostLike(host), + writeFileName: host.trace ? function (s) { return host.trace(s); } : undefined, + options: options, + baseCompilerOptions: baseCompilerOptions, + rootNames: rootNames, + baseWatchOptions: baseWatchOptions, + resolvedConfigFilePaths: ts.createMap(), + configFileCache: createConfigFileMap(), + projectStatus: createConfigFileMap(), + buildInfoChecked: createConfigFileMap(), + extendedConfigCache: ts.createMap(), + builderPrograms: createConfigFileMap(), + diagnostics: createConfigFileMap(), + projectPendingBuild: createConfigFileMap(), + projectErrorsReported: createConfigFileMap(), + compilerHost: compilerHost, + moduleResolutionCache: moduleResolutionCache, + buildOrder: undefined, + readFileWithCache: function (f) { return host.readFile(f); }, + projectCompilerOptions: baseCompilerOptions, + cache: undefined, + allProjectBuildPending: true, + needsSummary: true, + watchAllProjectsPending: watch, + currentInvalidatedProject: undefined, + watch: watch, + allWatchedWildcardDirectories: createConfigFileMap(), + allWatchedInputFiles: createConfigFileMap(), + allWatchedConfigFiles: createConfigFileMap(), + timerToBuildInvalidatedProject: undefined, + reportFileChangeDetected: false, + watchFile: watchFile, + watchFilePath: watchFilePath, + watchDirectory: watchDirectory, + writeLog: writeLog, + }; + return state; + } + function toPath(state, fileName) { + return ts.toPath(fileName, state.currentDirectory, state.getCanonicalFileName); + } + function toResolvedConfigFilePath(state, fileName) { + var resolvedConfigFilePaths = state.resolvedConfigFilePaths; + var path = resolvedConfigFilePaths.get(fileName); + if (path !== undefined) + return path; + var resolvedPath = toPath(state, fileName); + resolvedConfigFilePaths.set(fileName, resolvedPath); + return resolvedPath; + } + function isParsedCommandLine(entry) { + return !!entry.options; + } + function parseConfigFile(state, configFileName, configFilePath) { + var configFileCache = state.configFileCache; + var value = configFileCache.get(configFilePath); + if (value) { + return isParsedCommandLine(value) ? value : undefined; + } + var diagnostic; + var parseConfigFileHost = state.parseConfigFileHost, baseCompilerOptions = state.baseCompilerOptions, baseWatchOptions = state.baseWatchOptions, extendedConfigCache = state.extendedConfigCache, host = state.host; + var parsed; + if (host.getParsedCommandLine) { + parsed = host.getParsedCommandLine(configFileName); + if (!parsed) + diagnostic = ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, configFileName); + } + else { + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = function (d) { return diagnostic = d; }; + parsed = ts.getParsedCommandLineOfConfigFile(configFileName, baseCompilerOptions, parseConfigFileHost, extendedConfigCache, baseWatchOptions); + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = ts.noop; + } + configFileCache.set(configFilePath, parsed || diagnostic); + return parsed; + } + function resolveProjectName(state, name) { + return ts.resolveConfigFileProjectName(ts.resolvePath(state.currentDirectory, name)); + } + function createBuildOrder(state, roots) { + var temporaryMarks = ts.createMap(); + var permanentMarks = ts.createMap(); + var circularityReportStack = []; + var buildOrder; + var circularDiagnostics; + for (var _i = 0, roots_1 = roots; _i < roots_1.length; _i++) { + var root = roots_1[_i]; + visit(root); + } + return circularDiagnostics ? + { buildOrder: buildOrder || ts.emptyArray, circularDiagnostics: circularDiagnostics } : + buildOrder || ts.emptyArray; + function visit(configFileName, inCircularContext) { + var projPath = toResolvedConfigFilePath(state, configFileName); + if (permanentMarks.has(projPath)) + return; + if (temporaryMarks.has(projPath)) { + if (!inCircularContext) { + (circularDiagnostics || (circularDiagnostics = [])).push(ts.createCompilerDiagnostic(ts.Diagnostics.Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0, circularityReportStack.join("\r\n"))); + } + return; + } + temporaryMarks.set(projPath, true); + circularityReportStack.push(configFileName); + var parsed = parseConfigFile(state, configFileName, projPath); + if (parsed && parsed.projectReferences) { + for (var _i = 0, _a = parsed.projectReferences; _i < _a.length; _i++) { + var ref = _a[_i]; + var resolvedRefPath = resolveProjectName(state, ref.path); + visit(resolvedRefPath, inCircularContext || ref.circular); + } + } + circularityReportStack.pop(); + permanentMarks.set(projPath, true); + (buildOrder || (buildOrder = [])).push(configFileName); + } + } + function getBuildOrder(state) { + return state.buildOrder || createStateBuildOrder(state); + } + function createStateBuildOrder(state) { + var buildOrder = createBuildOrder(state, state.rootNames.map(function (f) { return resolveProjectName(state, f); })); + state.resolvedConfigFilePaths.clear(); + var currentProjects = ts.arrayToSet(getBuildOrderFromAnyBuildOrder(buildOrder), function (resolved) { return toResolvedConfigFilePath(state, resolved); }); + var noopOnDelete = { onDeleteValue: ts.noop }; + ts.mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.buildInfoChecked, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete); + if (state.watch) { + ts.mutateMapSkippingNewValues(state.allWatchedConfigFiles, currentProjects, { onDeleteValue: ts.closeFileWatcher }); + ts.mutateMapSkippingNewValues(state.allWatchedWildcardDirectories, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcherOf); } }); + ts.mutateMapSkippingNewValues(state.allWatchedInputFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } }); + } + return state.buildOrder = buildOrder; + } + function getBuildOrderFor(state, project, onlyReferences) { + var resolvedProject = project && resolveProjectName(state, project); + var buildOrderFromState = getBuildOrder(state); + if (isCircularBuildOrder(buildOrderFromState)) + return buildOrderFromState; + if (resolvedProject) { + var projectPath_1 = toResolvedConfigFilePath(state, resolvedProject); + var projectIndex = ts.findIndex(buildOrderFromState, function (configFileName) { return toResolvedConfigFilePath(state, configFileName) === projectPath_1; }); + if (projectIndex === -1) + return undefined; + } + var buildOrder = resolvedProject ? createBuildOrder(state, [resolvedProject]) : buildOrderFromState; + ts.Debug.assert(!isCircularBuildOrder(buildOrder)); + ts.Debug.assert(!onlyReferences || resolvedProject !== undefined); + ts.Debug.assert(!onlyReferences || buildOrder[buildOrder.length - 1] === resolvedProject); + return onlyReferences ? buildOrder.slice(0, buildOrder.length - 1) : buildOrder; + } + function enableCache(state) { + if (state.cache) { + disableCache(state); + } + var compilerHost = state.compilerHost, host = state.host; + var originalReadFileWithCache = state.readFileWithCache; + var originalGetSourceFile = compilerHost.getSourceFile; + var _a = ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return toPath(state, fileName); }, function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArrays([compilerHost], args)); + }), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile, getSourceFileWithCache = _a.getSourceFileWithCache, readFileWithCache = _a.readFileWithCache; + state.readFileWithCache = readFileWithCache; + compilerHost.getSourceFile = getSourceFileWithCache; + state.cache = { + originalReadFile: originalReadFile, + originalFileExists: originalFileExists, + originalDirectoryExists: originalDirectoryExists, + originalCreateDirectory: originalCreateDirectory, + originalWriteFile: originalWriteFile, + originalReadFileWithCache: originalReadFileWithCache, + originalGetSourceFile: originalGetSourceFile, + }; + } + function disableCache(state) { + if (!state.cache) + return; + var cache = state.cache, host = state.host, compilerHost = state.compilerHost, extendedConfigCache = state.extendedConfigCache, moduleResolutionCache = state.moduleResolutionCache; + host.readFile = cache.originalReadFile; + host.fileExists = cache.originalFileExists; + host.directoryExists = cache.originalDirectoryExists; + host.createDirectory = cache.originalCreateDirectory; + host.writeFile = cache.originalWriteFile; + compilerHost.getSourceFile = cache.originalGetSourceFile; + state.readFileWithCache = cache.originalReadFileWithCache; + extendedConfigCache.clear(); + if (moduleResolutionCache) { + moduleResolutionCache.directoryToModuleNameMap.clear(); + moduleResolutionCache.moduleNameToDirectoryMap.clear(); + } + state.cache = undefined; + } + function clearProjectStatus(state, resolved) { + state.projectStatus.delete(resolved); + state.diagnostics.delete(resolved); + } + function addProjToQueue(_a, proj, reloadLevel) { + var projectPendingBuild = _a.projectPendingBuild; + var value = projectPendingBuild.get(proj); + if (value === undefined) { + projectPendingBuild.set(proj, reloadLevel); + } + else if (value < reloadLevel) { + projectPendingBuild.set(proj, reloadLevel); + } + } + function setupInitialBuild(state, cancellationToken) { + if (!state.allProjectBuildPending) + return; + state.allProjectBuildPending = false; + if (state.options.watch) { + reportWatchStatus(state, ts.Diagnostics.Starting_compilation_in_watch_mode); + } + enableCache(state); + var buildOrder = getBuildOrderFromAnyBuildOrder(getBuildOrder(state)); + buildOrder.forEach(function (configFileName) { + return state.projectPendingBuild.set(toResolvedConfigFilePath(state, configFileName), ts.ConfigFileProgramReloadLevel.None); + }); + if (cancellationToken) { + cancellationToken.throwIfCancellationRequested(); + } + } + var InvalidatedProjectKind; + (function (InvalidatedProjectKind) { + InvalidatedProjectKind[InvalidatedProjectKind["Build"] = 0] = "Build"; + InvalidatedProjectKind[InvalidatedProjectKind["UpdateBundle"] = 1] = "UpdateBundle"; + InvalidatedProjectKind[InvalidatedProjectKind["UpdateOutputFileStamps"] = 2] = "UpdateOutputFileStamps"; + })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {})); + function doneInvalidatedProject(state, projectPath) { + state.projectPendingBuild.delete(projectPath); + state.currentInvalidatedProject = undefined; + return state.diagnostics.has(projectPath) ? + ts.ExitStatus.DiagnosticsPresent_OutputsSkipped : + ts.ExitStatus.Success; + } + function createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder) { + var updateOutputFileStampsPending = true; + return { + kind: InvalidatedProjectKind.UpdateOutputFileStamps, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + updateOutputFileStatmps: function () { + updateOutputTimestamps(state, config, projectPath); + updateOutputFileStampsPending = false; + }, + done: function () { + if (updateOutputFileStampsPending) { + updateOutputTimestamps(state, config, projectPath); + } + return doneInvalidatedProject(state, projectPath); + } + }; + } + function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath, projectIndex, config, buildOrder) { + var Step; + (function (Step) { + Step[Step["CreateProgram"] = 0] = "CreateProgram"; + Step[Step["SyntaxDiagnostics"] = 1] = "SyntaxDiagnostics"; + Step[Step["SemanticDiagnostics"] = 2] = "SemanticDiagnostics"; + Step[Step["Emit"] = 3] = "Emit"; + Step[Step["EmitBundle"] = 4] = "EmitBundle"; + Step[Step["BuildInvalidatedProjectOfBundle"] = 5] = "BuildInvalidatedProjectOfBundle"; + Step[Step["QueueReferencingProjects"] = 6] = "QueueReferencingProjects"; + Step[Step["Done"] = 7] = "Done"; + })(Step || (Step = {})); + var step = kind === InvalidatedProjectKind.Build ? Step.CreateProgram : Step.EmitBundle; + var program; + var buildResult; + var invalidatedProjectOfBundle; + return kind === InvalidatedProjectKind.Build ? + { + kind: kind, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + getBuilderProgram: function () { return withProgramOrUndefined(ts.identity); }, + getProgram: function () { + return withProgramOrUndefined(function (program) { return program.getProgramOrUndefined(); }); + }, + getSourceFile: function (fileName) { + return withProgramOrUndefined(function (program) { return program.getSourceFile(fileName); }); + }, + getSourceFiles: function () { + return withProgramOrEmptyArray(function (program) { return program.getSourceFiles(); }); + }, + getOptionsDiagnostics: function (cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getOptionsDiagnostics(cancellationToken); }); + }, + getGlobalDiagnostics: function (cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getGlobalDiagnostics(cancellationToken); }); + }, + getConfigFileParsingDiagnostics: function () { + return withProgramOrEmptyArray(function (program) { return program.getConfigFileParsingDiagnostics(); }); + }, + getSyntacticDiagnostics: function (sourceFile, cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getSyntacticDiagnostics(sourceFile, cancellationToken); }); + }, + getAllDependencies: function (sourceFile) { + return withProgramOrEmptyArray(function (program) { return program.getAllDependencies(sourceFile); }); + }, + getSemanticDiagnostics: function (sourceFile, cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getSemanticDiagnostics(sourceFile, cancellationToken); }); + }, + getSemanticDiagnosticsOfNextAffectedFile: function (cancellationToken, ignoreSourceFile) { + return withProgramOrUndefined(function (program) { + return (program.getSemanticDiagnosticsOfNextAffectedFile) && + program.getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile); + }); + }, + emit: function (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + if (targetSourceFile || emitOnlyDtsFiles) { + return withProgramOrUndefined(function (program) { return program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers); }); + } + executeSteps(Step.SemanticDiagnostics, cancellationToken); + if (step !== Step.Emit) + return undefined; + return emit(writeFile, cancellationToken, customTransformers); + }, + done: done + } : + { + kind: kind, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + emit: function (writeFile, customTransformers) { + if (step !== Step.EmitBundle) + return invalidatedProjectOfBundle; + return emitBundle(writeFile, customTransformers); + }, + done: done, + }; + function done(cancellationToken, writeFile, customTransformers) { + executeSteps(Step.Done, cancellationToken, writeFile, customTransformers); + return doneInvalidatedProject(state, projectPath); + } + function withProgramOrUndefined(action) { + executeSteps(Step.CreateProgram); + return program && action(program); + } + function withProgramOrEmptyArray(action) { + return withProgramOrUndefined(action) || ts.emptyArray; + } + function createProgram() { + ts.Debug.assert(program === undefined); + if (state.options.dry) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_build_project_0, project); + buildResult = BuildResultFlags.Success; + step = Step.QueueReferencingProjects; + return; + } + if (state.options.verbose) + reportStatus(state, ts.Diagnostics.Building_project_0, project); + if (config.fileNames.length === 0) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + buildResult = BuildResultFlags.None; + step = Step.QueueReferencingProjects; + return; + } + var host = state.host, compilerHost = state.compilerHost; + state.projectCompilerOptions = config.options; + updateModuleResolutionCache(state, project, config); + program = host.createProgram(config.fileNames, config.options, compilerHost, getOldProgram(state, projectPath, config), ts.getConfigFileParsingDiagnostics(config), config.projectReferences); + step++; + } + function handleDiagnostics(diagnostics, errorFlags, errorType) { + if (diagnostics.length) { + buildResult = buildErrors(state, projectPath, program, config, diagnostics, errorFlags, errorType); + step = Step.QueueReferencingProjects; + } + else { + step++; + } + } + function getSyntaxDiagnostics(cancellationToken) { + ts.Debug.assertDefined(program); + handleDiagnostics(__spreadArrays(program.getConfigFileParsingDiagnostics(), program.getOptionsDiagnostics(cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSyntacticDiagnostics(undefined, cancellationToken)), BuildResultFlags.SyntaxErrors, "Syntactic"); + } + function getSemanticDiagnostics(cancellationToken) { + handleDiagnostics(ts.Debug.assertDefined(program).getSemanticDiagnostics(undefined, cancellationToken), BuildResultFlags.TypeErrors, "Semantic"); + } + function emit(writeFileCallback, cancellationToken, customTransformers) { + ts.Debug.assertDefined(program); + ts.Debug.assert(step === Step.Emit); + program.backupState(); + var declDiagnostics; + var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); }; + var outputFiles = []; + var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, undefined, undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, false, customTransformers).emitResult; + if (declDiagnostics) { + program.restoreState(); + buildResult = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file"); + step = Step.QueueReferencingProjects; + return { + emitSkipped: true, + diagnostics: emitResult.diagnostics + }; + } + var host = state.host, compilerHost = state.compilerHost; + var resultFlags = BuildResultFlags.DeclarationOutputUnchanged; + var newestDeclarationFileContentChangedTime = minimumDate; + var anyDtsChanged = false; + var emitterDiagnostics = ts.createDiagnosticCollection(); + var emittedOutputs = ts.createMap(); + outputFiles.forEach(function (_a) { + var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark; + var priorChangeTime; + if (!anyDtsChanged && isDeclarationFile(name)) { + if (host.fileExists(name) && state.readFileWithCache(name) === text) { + priorChangeTime = host.getModifiedTime(name); + } + else { + resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged; + anyDtsChanged = true; + } + } + emittedOutputs.set(toPath(state, name), name); + ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark); + if (priorChangeTime !== undefined) { + newestDeclarationFileContentChangedTime = newer(priorChangeTime, newestDeclarationFileContentChangedTime); + } + }); + finishEmit(emitterDiagnostics, emittedOutputs, newestDeclarationFileContentChangedTime, anyDtsChanged, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags); + return emitResult; + } + function finishEmit(emitterDiagnostics, emittedOutputs, priorNewestUpdateTime, newestDeclarationFileContentChangedTimeIsMaximumDate, oldestOutputFileName, resultFlags) { + var emitDiagnostics = emitterDiagnostics.getDiagnostics(); + if (emitDiagnostics.length) { + buildResult = buildErrors(state, projectPath, program, config, emitDiagnostics, BuildResultFlags.EmitErrors, "Emit"); + step = Step.QueueReferencingProjects; + return emitDiagnostics; + } + if (state.writeFileName) { + emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); }); + if (program) + ts.listFiles(program, state.writeFileName); + } + var newestDeclarationFileContentChangedTime = updateOutputTimestampsWorker(state, config, priorNewestUpdateTime, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs); + state.diagnostics.delete(projectPath); + state.projectStatus.set(projectPath, { + type: ts.UpToDateStatusType.UpToDate, + newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTimeIsMaximumDate ? + maximumDate : + newestDeclarationFileContentChangedTime, + oldestOutputFileName: oldestOutputFileName + }); + afterProgramDone(state, projectPath, program, config); + state.projectCompilerOptions = state.baseCompilerOptions; + step = Step.QueueReferencingProjects; + buildResult = resultFlags; + return emitDiagnostics; + } + function emitBundle(writeFileCallback, customTransformers) { + ts.Debug.assert(kind === InvalidatedProjectKind.UpdateBundle); + if (state.options.dry) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_output_of_project_0, project); + buildResult = BuildResultFlags.Success; + step = Step.QueueReferencingProjects; + return undefined; + } + if (state.options.verbose) + reportStatus(state, ts.Diagnostics.Updating_output_of_project_0, project); + var compilerHost = state.compilerHost; + state.projectCompilerOptions = config.options; + var outputFiles = ts.emitUsingBuildInfo(config, compilerHost, function (ref) { + var refName = resolveProjectName(state, ref.path); + return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName)); + }, customTransformers); + if (ts.isString(outputFiles)) { + reportStatus(state, ts.Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles)); + step = Step.BuildInvalidatedProjectOfBundle; + return invalidatedProjectOfBundle = createBuildOrUpdateInvalidedProject(InvalidatedProjectKind.Build, state, project, projectPath, projectIndex, config, buildOrder); + } + ts.Debug.assert(!!outputFiles.length); + var emitterDiagnostics = ts.createDiagnosticCollection(); + var emittedOutputs = ts.createMap(); + outputFiles.forEach(function (_a) { + var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark; + emittedOutputs.set(toPath(state, name), name); + ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark); + }); + var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, minimumDate, false, outputFiles[0].name, BuildResultFlags.DeclarationOutputUnchanged); + return { emitSkipped: false, diagnostics: emitDiagnostics }; + } + function executeSteps(till, cancellationToken, writeFile, customTransformers) { + while (step <= till && step < Step.Done) { + var currentStep = step; + switch (step) { + case Step.CreateProgram: + createProgram(); + break; + case Step.SyntaxDiagnostics: + getSyntaxDiagnostics(cancellationToken); + break; + case Step.SemanticDiagnostics: + getSemanticDiagnostics(cancellationToken); + break; + case Step.Emit: + emit(writeFile, cancellationToken, customTransformers); + break; + case Step.EmitBundle: + emitBundle(writeFile, customTransformers); + break; + case Step.BuildInvalidatedProjectOfBundle: + ts.Debug.assertDefined(invalidatedProjectOfBundle).done(cancellationToken); + step = Step.Done; + break; + case Step.QueueReferencingProjects: + queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, ts.Debug.assertDefined(buildResult)); + step++; + break; + case Step.Done: + default: + ts.assertType(step); + } + ts.Debug.assert(step > currentStep); + } + } + } + function needsBuild(_a, status, config) { + var options = _a.options; + if (status.type !== ts.UpToDateStatusType.OutOfDateWithPrepend || options.force) + return true; + return config.fileNames.length === 0 || + !!ts.getConfigFileParsingDiagnostics(config).length || + !ts.isIncrementalCompilation(config.options); + } + function getNextInvalidatedProject(state, buildOrder, reportQueue) { + if (!state.projectPendingBuild.size) + return undefined; + if (isCircularBuildOrder(buildOrder)) + return undefined; + if (state.currentInvalidatedProject) { + return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ? + state.currentInvalidatedProject : + undefined; + } + var options = state.options, projectPendingBuild = state.projectPendingBuild; + for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) { + var project = buildOrder[projectIndex]; + var projectPath = toResolvedConfigFilePath(state, project); + var reloadLevel = state.projectPendingBuild.get(projectPath); + if (reloadLevel === undefined) + continue; + if (reportQueue) { + reportQueue = false; + reportBuildQueue(state, buildOrder); + } + var config = parseConfigFile(state, project, projectPath); + if (!config) { + reportParseConfigFileDiagnostic(state, projectPath); + projectPendingBuild.delete(projectPath); + continue; + } + if (reloadLevel === ts.ConfigFileProgramReloadLevel.Full) { + watchConfigFile(state, project, projectPath, config); + watchWildCardDirectories(state, project, projectPath, config); + watchInputFiles(state, project, projectPath, config); + } + else if (reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) { + var result = ts.getFileNamesFromConfigSpecs(config.configFileSpecs, ts.getDirectoryPath(project), config.options, state.parseConfigFileHost); + ts.updateErrorForNoInputFiles(result, project, config.configFileSpecs, config.errors, ts.canJsonReportNoInutFiles(config.raw)); + config.fileNames = result.fileNames; + watchInputFiles(state, project, projectPath, config); + } + var status = getUpToDateStatus(state, config, projectPath); + verboseReportProjectStatus(state, project, status); + if (!options.force) { + if (status.type === ts.UpToDateStatusType.UpToDate) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + if (options.dry) { + reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date, project); + } + continue; + } + if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder); + } + } + if (status.type === ts.UpToDateStatusType.UpstreamBlocked) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + if (options.verbose) { + reportStatus(state, status.upstreamProjectBlocked ? + ts.Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_was_not_built : + ts.Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_has_errors, project, status.upstreamProjectName); + } + continue; + } + if (status.type === ts.UpToDateStatusType.ContainerOnly) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + continue; + } + return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ? + InvalidatedProjectKind.Build : + InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder); + } + return undefined; + } + function listEmittedFile(_a, proj, file) { + var writeFileName = _a.writeFileName; + if (writeFileName && proj.options.listEmittedFiles) { + writeFileName("TSFILE: " + file); + } + } + function getOldProgram(_a, proj, parsed) { + var options = _a.options, builderPrograms = _a.builderPrograms, compilerHost = _a.compilerHost; + if (options.force) + return undefined; + var value = builderPrograms.get(proj); + if (value) + return value; + return ts.readBuilderProgram(parsed.options, compilerHost); + } + function afterProgramDone(_a, proj, program, config) { + var host = _a.host, watch = _a.watch, builderPrograms = _a.builderPrograms; + if (program) { + if (host.afterProgramEmitAndDiagnostics) { + host.afterProgramEmitAndDiagnostics(program); + } + if (watch) { + program.releaseProgram(); + builderPrograms.set(proj, program); + } + } + else if (host.afterEmitBundle) { + host.afterEmitBundle(config); + } + } + function buildErrors(state, resolvedPath, program, config, diagnostics, errorFlags, errorType) { + reportAndStoreErrors(state, resolvedPath, diagnostics); + if (program && state.writeFileName) + ts.listFiles(program, state.writeFileName); + state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" }); + afterProgramDone(state, resolvedPath, program, config); + state.projectCompilerOptions = state.baseCompilerOptions; + return errorFlags; + } + function updateModuleResolutionCache(state, proj, config) { + if (!state.moduleResolutionCache) + return; + var moduleResolutionCache = state.moduleResolutionCache; + var projPath = toPath(state, proj); + if (moduleResolutionCache.directoryToModuleNameMap.redirectsMap.size === 0) { + ts.Debug.assert(moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.size === 0); + moduleResolutionCache.directoryToModuleNameMap.redirectsMap.set(projPath, moduleResolutionCache.directoryToModuleNameMap.ownMap); + moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.set(projPath, moduleResolutionCache.moduleNameToDirectoryMap.ownMap); + } + else { + ts.Debug.assert(moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.size > 0); + var ref = { + sourceFile: config.options.configFile, + commandLine: config + }; + moduleResolutionCache.directoryToModuleNameMap.setOwnMap(moduleResolutionCache.directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref)); + moduleResolutionCache.moduleNameToDirectoryMap.setOwnMap(moduleResolutionCache.moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref)); + } + moduleResolutionCache.directoryToModuleNameMap.setOwnOptions(config.options); + moduleResolutionCache.moduleNameToDirectoryMap.setOwnOptions(config.options); + } + function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) { + var tsconfigTime = state.host.getModifiedTime(configFile) || ts.missingFileModifiedTime; + if (oldestOutputFileTime < tsconfigTime) { + return { + type: ts.UpToDateStatusType.OutOfDateWithSelf, + outOfDateOutputFileName: oldestOutputFileName, + newerInputFileName: configFile + }; + } + } + function getUpToDateStatusWorker(state, project, resolvedPath) { + var newestInputFileName = undefined; + var newestInputFileTime = minimumDate; + var host = state.host; + for (var _i = 0, _a = project.fileNames; _i < _a.length; _i++) { + var inputFile = _a[_i]; + if (!host.fileExists(inputFile)) { + return { + type: ts.UpToDateStatusType.Unbuildable, + reason: inputFile + " does not exist" + }; + } + var inputTime = host.getModifiedTime(inputFile) || ts.missingFileModifiedTime; + if (inputTime > newestInputFileTime) { + newestInputFileName = inputFile; + newestInputFileTime = inputTime; + } + } + if (!project.fileNames.length && !ts.canJsonReportNoInutFiles(project.raw)) { + return { + type: ts.UpToDateStatusType.ContainerOnly + }; + } + var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames()); + var oldestOutputFileName = "(none)"; + var oldestOutputFileTime = maximumDate; + var newestOutputFileName = "(none)"; + var newestOutputFileTime = minimumDate; + var missingOutputFileName; + var newestDeclarationFileContentChangedTime = minimumDate; + var isOutOfDateWithInputs = false; + for (var _b = 0, outputs_1 = outputs; _b < outputs_1.length; _b++) { + var output = outputs_1[_b]; + if (!host.fileExists(output)) { + missingOutputFileName = output; + break; + } + var outputTime = host.getModifiedTime(output) || ts.missingFileModifiedTime; + if (outputTime < oldestOutputFileTime) { + oldestOutputFileTime = outputTime; + oldestOutputFileName = output; + } + if (outputTime < newestInputFileTime) { + isOutOfDateWithInputs = true; + break; + } + if (outputTime > newestOutputFileTime) { + newestOutputFileTime = outputTime; + newestOutputFileName = output; + } + if (isDeclarationFile(output)) { + var outputModifiedTime = host.getModifiedTime(output) || ts.missingFileModifiedTime; + newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputModifiedTime); + } + } + var pseudoUpToDate = false; + var usesPrepend = false; + var upstreamChangedProject; + if (project.projectReferences) { + state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.ComputingUpstream }); + for (var _c = 0, _d = project.projectReferences; _c < _d.length; _c++) { + var ref = _d[_c]; + usesPrepend = usesPrepend || !!(ref.prepend); + var resolvedRef = ts.resolveProjectReferencePath(ref); + var resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef); + var refStatus = getUpToDateStatus(state, parseConfigFile(state, resolvedRef, resolvedRefPath), resolvedRefPath); + if (refStatus.type === ts.UpToDateStatusType.ComputingUpstream || + refStatus.type === ts.UpToDateStatusType.ContainerOnly) { + continue; + } + if (refStatus.type === ts.UpToDateStatusType.Unbuildable || + refStatus.type === ts.UpToDateStatusType.UpstreamBlocked) { + return { + type: ts.UpToDateStatusType.UpstreamBlocked, + upstreamProjectName: ref.path, + upstreamProjectBlocked: refStatus.type === ts.UpToDateStatusType.UpstreamBlocked + }; + } + if (refStatus.type !== ts.UpToDateStatusType.UpToDate) { + return { + type: ts.UpToDateStatusType.UpstreamOutOfDate, + upstreamProjectName: ref.path + }; + } + if (!missingOutputFileName) { + if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) { + continue; + } + if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) { + pseudoUpToDate = true; + upstreamChangedProject = ref.path; + continue; + } + ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here"); + return { + type: ts.UpToDateStatusType.OutOfDateWithUpstream, + outOfDateOutputFileName: oldestOutputFileName, + newerProjectName: ref.path + }; + } + } + } + if (missingOutputFileName !== undefined) { + return { + type: ts.UpToDateStatusType.OutputMissing, + missingOutputFileName: missingOutputFileName + }; + } + if (isOutOfDateWithInputs) { + return { + type: ts.UpToDateStatusType.OutOfDateWithSelf, + outOfDateOutputFileName: oldestOutputFileName, + newerInputFileName: newestInputFileName + }; + } + else { + var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName); + if (configStatus) + return configStatus; + var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); }); + if (extendedConfigStatus) + return extendedConfigStatus; + } + if (!state.buildInfoChecked.has(resolvedPath)) { + state.buildInfoChecked.set(resolvedPath, true); + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options); + if (buildInfoPath) { + var value = state.readFileWithCache(buildInfoPath); + var buildInfo = value && ts.getBuildInfo(value); + if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) { + return { + type: ts.UpToDateStatusType.TsVersionOutputOfDate, + version: buildInfo.version + }; + } + } + } + if (usesPrepend && pseudoUpToDate) { + return { + type: ts.UpToDateStatusType.OutOfDateWithPrepend, + outOfDateOutputFileName: oldestOutputFileName, + newerProjectName: upstreamChangedProject + }; + } + return { + type: pseudoUpToDate ? ts.UpToDateStatusType.UpToDateWithUpstreamTypes : ts.UpToDateStatusType.UpToDate, + newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime, + newestInputFileTime: newestInputFileTime, + newestOutputFileTime: newestOutputFileTime, + newestInputFileName: newestInputFileName, + newestOutputFileName: newestOutputFileName, + oldestOutputFileName: oldestOutputFileName + }; + } + function getUpToDateStatus(state, project, resolvedPath) { + if (project === undefined) { + return { type: ts.UpToDateStatusType.Unbuildable, reason: "File deleted mid-build" }; + } + var prior = state.projectStatus.get(resolvedPath); + if (prior !== undefined) { + return prior; + } + var actual = getUpToDateStatusWorker(state, project, resolvedPath); + state.projectStatus.set(resolvedPath, actual); + return actual; + } + function updateOutputTimestampsWorker(state, proj, priorNewestUpdateTime, verboseMessage, skipOutputs) { + var host = state.host; + var outputs = ts.getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames()); + if (!skipOutputs || outputs.length !== skipOutputs.size) { + var reportVerbose = !!state.options.verbose; + var now = host.now ? host.now() : new Date(); + for (var _i = 0, outputs_2 = outputs; _i < outputs_2.length; _i++) { + var file = outputs_2[_i]; + if (skipOutputs && skipOutputs.has(toPath(state, file))) { + continue; + } + if (reportVerbose) { + reportVerbose = false; + reportStatus(state, verboseMessage, proj.options.configFilePath); + } + if (isDeclarationFile(file)) { + priorNewestUpdateTime = newer(priorNewestUpdateTime, host.getModifiedTime(file) || ts.missingFileModifiedTime); + } + host.setModifiedTime(file, now); + } + } + return priorNewestUpdateTime; + } + function updateOutputTimestamps(state, proj, resolvedPath) { + if (state.options.dry) { + return reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath); + } + var priorNewestUpdateTime = updateOutputTimestampsWorker(state, proj, minimumDate, ts.Diagnostics.Updating_output_timestamps_of_project_0); + state.projectStatus.set(resolvedPath, { + type: ts.UpToDateStatusType.UpToDate, + newestDeclarationFileContentChangedTime: priorNewestUpdateTime, + oldestOutputFileName: ts.getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames()) + }); + } + function queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, buildResult) { + if (buildResult & BuildResultFlags.AnyErrors) + return; + if (!config.options.composite) + return; + for (var index = projectIndex + 1; index < buildOrder.length; index++) { + var nextProject = buildOrder[index]; + var nextProjectPath = toResolvedConfigFilePath(state, nextProject); + if (state.projectPendingBuild.has(nextProjectPath)) + continue; + var nextProjectConfig = parseConfigFile(state, nextProject, nextProjectPath); + if (!nextProjectConfig || !nextProjectConfig.projectReferences) + continue; + for (var _i = 0, _a = nextProjectConfig.projectReferences; _i < _a.length; _i++) { + var ref = _a[_i]; + var resolvedRefPath = resolveProjectName(state, ref.path); + if (toResolvedConfigFilePath(state, resolvedRefPath) !== projectPath) + continue; + var status = state.projectStatus.get(nextProjectPath); + if (status) { + switch (status.type) { + case ts.UpToDateStatusType.UpToDate: + if (buildResult & BuildResultFlags.DeclarationOutputUnchanged) { + if (ref.prepend) { + state.projectStatus.set(nextProjectPath, { + type: ts.UpToDateStatusType.OutOfDateWithPrepend, + outOfDateOutputFileName: status.oldestOutputFileName, + newerProjectName: project + }); + } + else { + status.type = ts.UpToDateStatusType.UpToDateWithUpstreamTypes; + } + break; + } + case ts.UpToDateStatusType.UpToDateWithUpstreamTypes: + case ts.UpToDateStatusType.OutOfDateWithPrepend: + if (!(buildResult & BuildResultFlags.DeclarationOutputUnchanged)) { + state.projectStatus.set(nextProjectPath, { + type: ts.UpToDateStatusType.OutOfDateWithUpstream, + outOfDateOutputFileName: status.type === ts.UpToDateStatusType.OutOfDateWithPrepend ? status.outOfDateOutputFileName : status.oldestOutputFileName, + newerProjectName: project + }); + } + break; + case ts.UpToDateStatusType.UpstreamBlocked: + if (toResolvedConfigFilePath(state, resolveProjectName(state, status.upstreamProjectName)) === projectPath) { + clearProjectStatus(state, nextProjectPath); + } + break; + } + } + addProjToQueue(state, nextProjectPath, ts.ConfigFileProgramReloadLevel.None); + break; + } + } + } + function build(state, project, cancellationToken, onlyReferences) { + var buildOrder = getBuildOrderFor(state, project, onlyReferences); + if (!buildOrder) + return ts.ExitStatus.InvalidProject_OutputsSkipped; + setupInitialBuild(state, cancellationToken); + var reportQueue = true; + var successfulProjects = 0; + while (true) { + var invalidatedProject = getNextInvalidatedProject(state, buildOrder, reportQueue); + if (!invalidatedProject) + break; + reportQueue = false; + invalidatedProject.done(cancellationToken); + if (!state.diagnostics.has(invalidatedProject.projectPath)) + successfulProjects++; + } + disableCache(state); + reportErrorSummary(state, buildOrder); + startWatching(state, buildOrder); + return isCircularBuildOrder(buildOrder) + ? ts.ExitStatus.ProjectReferenceCycle_OutputsSkipped + : !buildOrder.some(function (p) { return state.diagnostics.has(toResolvedConfigFilePath(state, p)); }) + ? ts.ExitStatus.Success + : successfulProjects + ? ts.ExitStatus.DiagnosticsPresent_OutputsGenerated + : ts.ExitStatus.DiagnosticsPresent_OutputsSkipped; + } + function clean(state, project, onlyReferences) { + var buildOrder = getBuildOrderFor(state, project, onlyReferences); + if (!buildOrder) + return ts.ExitStatus.InvalidProject_OutputsSkipped; + if (isCircularBuildOrder(buildOrder)) { + reportErrors(state, buildOrder.circularDiagnostics); + return ts.ExitStatus.ProjectReferenceCycle_OutputsSkipped; + } + var options = state.options, host = state.host; + var filesToDelete = options.dry ? [] : undefined; + for (var _i = 0, buildOrder_1 = buildOrder; _i < buildOrder_1.length; _i++) { + var proj = buildOrder_1[_i]; + var resolvedPath = toResolvedConfigFilePath(state, proj); + var parsed = parseConfigFile(state, proj, resolvedPath); + if (parsed === undefined) { + reportParseConfigFileDiagnostic(state, resolvedPath); + continue; + } + var outputs = ts.getAllProjectOutputs(parsed, !host.useCaseSensitiveFileNames()); + for (var _a = 0, outputs_3 = outputs; _a < outputs_3.length; _a++) { + var output = outputs_3[_a]; + if (host.fileExists(output)) { + if (filesToDelete) { + filesToDelete.push(output); + } + else { + host.deleteFile(output); + invalidateProject(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); + } + } + } + } + if (filesToDelete) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map(function (f) { return "\r\n * " + f; }).join("")); + } + return ts.ExitStatus.Success; + } + function invalidateProject(state, resolved, reloadLevel) { + if (state.host.getParsedCommandLine && reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) { + reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + } + if (reloadLevel === ts.ConfigFileProgramReloadLevel.Full) { + state.configFileCache.delete(resolved); + state.buildOrder = undefined; + } + state.needsSummary = true; + clearProjectStatus(state, resolved); + addProjToQueue(state, resolved, reloadLevel); + enableCache(state); + } + function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) { + state.reportFileChangeDetected = true; + invalidateProject(state, resolvedPath, reloadLevel); + scheduleBuildInvalidatedProject(state); + } + function scheduleBuildInvalidatedProject(state) { + var hostWithWatch = state.hostWithWatch; + if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) { + return; + } + if (state.timerToBuildInvalidatedProject) { + hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject); + } + state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state); + } + function buildNextInvalidatedProject(state) { + state.timerToBuildInvalidatedProject = undefined; + if (state.reportFileChangeDetected) { + state.reportFileChangeDetected = false; + state.projectErrorsReported.clear(); + reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation); + } + var buildOrder = getBuildOrder(state); + var invalidatedProject = getNextInvalidatedProject(state, buildOrder, false); + if (invalidatedProject) { + invalidatedProject.done(); + if (state.projectPendingBuild.size) { + if (state.watch && !state.timerToBuildInvalidatedProject) { + scheduleBuildInvalidatedProject(state); + } + return; + } + } + disableCache(state); + reportErrorSummary(state, buildOrder); + } + function watchConfigFile(state, resolved, resolvedPath, parsed) { + if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath)) + return; + state.allWatchedConfigFiles.set(resolvedPath, state.watchFile(state.hostWithWatch, resolved, function () { + invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); + }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved)); + } + function isSameFile(state, file1, file2) { + return ts.comparePaths(file1, file2, state.currentDirectory, !state.host.useCaseSensitiveFileNames()) === 0; + } + function isOutputFile(state, fileName, configFile) { + if (configFile.options.noEmit) + return false; + if (!ts.fileExtensionIs(fileName, ".d.ts") && + (ts.fileExtensionIs(fileName, ".ts") || ts.fileExtensionIs(fileName, ".tsx"))) { + return false; + } + var out = configFile.options.outFile || configFile.options.out; + if (out && (isSameFile(state, fileName, out) || isSameFile(state, fileName, ts.removeFileExtension(out) + ".d.ts"))) { + return true; + } + if (configFile.options.declarationDir && ts.containsPath(configFile.options.declarationDir, fileName, state.currentDirectory, !state.host.useCaseSensitiveFileNames())) { + return true; + } + if (configFile.options.outDir && ts.containsPath(configFile.options.outDir, fileName, state.currentDirectory, !state.host.useCaseSensitiveFileNames())) { + return true; + } + return !ts.forEach(configFile.fileNames, function (inputFile) { return isSameFile(state, fileName, inputFile); }); + } + function watchWildCardDirectories(state, resolved, resolvedPath, parsed) { + if (!state.watch) + return; + ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), ts.createMapFromTemplate(parsed.configFileSpecs.wildcardDirectories), function (dir, flags) { return state.watchDirectory(state.hostWithWatch, dir, function (fileOrDirectory) { + var fileOrDirectoryPath = toPath(state, fileOrDirectory); + if (fileOrDirectoryPath !== toPath(state, dir) && ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, parsed.options)) { + state.writeLog("Project: " + resolved + " Detected file add/remove of non supported extension: " + fileOrDirectory); + return; + } + if (isOutputFile(state, fileOrDirectory, parsed)) { + state.writeLog(fileOrDirectory + " is output file"); + return; + } + invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Partial); + }, flags, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.WildcardDirectory, resolved); }); + } + function watchInputFiles(state, resolved, resolvedPath, parsed) { + if (!state.watch) + return; + ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath), ts.arrayToMap(parsed.fileNames, function (fileName) { return toPath(state, fileName); }), { + createNewValue: function (path, input) { return state.watchFilePath(state.hostWithWatch, input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, path, ts.WatchType.SourceFile, resolved); }, + onDeleteValue: ts.closeFileWatcher, + }); + } + function startWatching(state, buildOrder) { + if (!state.watchAllProjectsPending) + return; + state.watchAllProjectsPending = false; + for (var _i = 0, _a = getBuildOrderFromAnyBuildOrder(buildOrder); _i < _a.length; _i++) { + var resolved = _a[_i]; + var resolvedPath = toResolvedConfigFilePath(state, resolved); + var cfg = parseConfigFile(state, resolved, resolvedPath); + watchConfigFile(state, resolved, resolvedPath, cfg); + if (cfg) { + watchWildCardDirectories(state, resolved, resolvedPath, cfg); + watchInputFiles(state, resolved, resolvedPath, cfg); + } + } + } + function stopWatching(state) { + ts.clearMap(state.allWatchedConfigFiles, ts.closeFileWatcher); + ts.clearMap(state.allWatchedWildcardDirectories, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); }); + ts.clearMap(state.allWatchedInputFiles, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcher); }); + } + function createSolutionBuilderWorker(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) { + var state = createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions); + return { + build: function (project, cancellationToken) { return build(state, project, cancellationToken); }, + clean: function (project) { return clean(state, project); }, + buildReferences: function (project, cancellationToken) { return build(state, project, cancellationToken, true); }, + cleanReferences: function (project) { return clean(state, project, true); }, + getNextInvalidatedProject: function (cancellationToken) { + setupInitialBuild(state, cancellationToken); + return getNextInvalidatedProject(state, getBuildOrder(state), false); + }, + getBuildOrder: function () { return getBuildOrder(state); }, + getUpToDateStatusOfProject: function (project) { + var configFileName = resolveProjectName(state, project); + var configFilePath = toResolvedConfigFilePath(state, configFileName); + return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath); + }, + invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); }, + buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); }, + getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); }, + close: function () { return stopWatching(state); }, + }; + } + function relName(state, path) { + return ts.convertToRelativePath(path, state.currentDirectory, function (f) { return state.getCanonicalFileName(f); }); + } + function reportStatus(state, message) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + state.host.reportSolutionBuilderStatus(ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args))); + } + function reportWatchStatus(state, message) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + if (state.hostWithWatch.onWatchStatusChange) { + state.hostWithWatch.onWatchStatusChange(ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args)), state.host.getNewLine(), state.baseCompilerOptions); + } + } + function reportErrors(_a, errors) { + var host = _a.host; + errors.forEach(function (err) { return host.reportDiagnostic(err); }); + } + function reportAndStoreErrors(state, proj, errors) { + reportErrors(state, errors); + state.projectErrorsReported.set(proj, true); + if (errors.length) { + state.diagnostics.set(proj, errors); + } + } + function reportParseConfigFileDiagnostic(state, proj) { + reportAndStoreErrors(state, proj, [state.configFileCache.get(proj)]); + } + function reportErrorSummary(state, buildOrder) { + if (!state.needsSummary) + return; + state.needsSummary = false; + var canReportSummary = state.watch || !!state.host.reportErrorSummary; + var diagnostics = state.diagnostics; + var totalErrors = 0; + if (isCircularBuildOrder(buildOrder)) { + reportBuildQueue(state, buildOrder.buildOrder); + reportErrors(state, buildOrder.circularDiagnostics); + if (canReportSummary) + totalErrors += ts.getErrorCountForSummary(buildOrder.circularDiagnostics); + } + else { + buildOrder.forEach(function (project) { + var projectPath = toResolvedConfigFilePath(state, project); + if (!state.projectErrorsReported.has(projectPath)) { + reportErrors(state, diagnostics.get(projectPath) || ts.emptyArray); + } + }); + if (canReportSummary) + diagnostics.forEach(function (singleProjectErrors) { return totalErrors += ts.getErrorCountForSummary(singleProjectErrors); }); + } + if (state.watch) { + reportWatchStatus(state, ts.getWatchErrorSummaryDiagnosticMessage(totalErrors), totalErrors); + } + else if (state.host.reportErrorSummary) { + state.host.reportErrorSummary(totalErrors); + } + } + function reportBuildQueue(state, buildQueue) { + if (state.options.verbose) { + reportStatus(state, ts.Diagnostics.Projects_in_this_build_Colon_0, buildQueue.map(function (s) { return "\r\n * " + relName(state, s); }).join("")); + } + } + function reportUpToDateStatus(state, configFileName, status) { + switch (status.type) { + case ts.UpToDateStatusType.OutOfDateWithSelf: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName)); + case ts.UpToDateStatusType.OutOfDateWithUpstream: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName)); + case ts.UpToDateStatusType.OutputMissing: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, relName(state, configFileName), relName(state, status.missingOutputFileName)); + case ts.UpToDateStatusType.UpToDate: + if (status.newestInputFileTime !== undefined) { + return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || "")); + } + break; + case ts.UpToDateStatusType.OutOfDateWithPrepend: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relName(state, configFileName), relName(state, status.newerProjectName)); + case ts.UpToDateStatusType.UpToDateWithUpstreamTypes: + return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, relName(state, configFileName)); + case ts.UpToDateStatusType.UpstreamOutOfDate: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date, relName(state, configFileName), relName(state, status.upstreamProjectName)); + case ts.UpToDateStatusType.UpstreamBlocked: + return reportStatus(state, status.upstreamProjectBlocked ? + ts.Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_was_not_built : + ts.Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_has_errors, relName(state, configFileName), relName(state, status.upstreamProjectName)); + case ts.UpToDateStatusType.Unbuildable: + return reportStatus(state, ts.Diagnostics.Failed_to_parse_file_0_Colon_1, relName(state, configFileName), status.reason); + case ts.UpToDateStatusType.TsVersionOutputOfDate: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2, relName(state, configFileName), status.version, ts.version); + case ts.UpToDateStatusType.ContainerOnly: + case ts.UpToDateStatusType.ComputingUpstream: + break; + default: + ts.assertType(status); + } + } + function verboseReportProjectStatus(state, configFileName, status) { + if (state.options.verbose) { + reportUpToDateStatus(state, configFileName, status); + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function countLines(program) { + var count = 0; + ts.forEach(program.getSourceFiles(), function (file) { + count += ts.getLineStarts(file).length; + }); + return count; + } + function updateReportDiagnostic(sys, existing, options) { + return shouldBePretty(sys, options) ? + ts.createDiagnosticReporter(sys, true) : + existing; + } + function defaultIsPretty(sys) { + return !!sys.writeOutputIsTTY && sys.writeOutputIsTTY(); + } + function shouldBePretty(sys, options) { + if (!options || typeof options.pretty === "undefined") { + return defaultIsPretty(sys); + } + return options.pretty; + } + function padLeft(s, length) { + while (s.length < length) { + s = " " + s; + } + return s; + } + function padRight(s, length) { + while (s.length < length) { + s = s + " "; + } + return s; + } + function getOptionsForHelp(commandLine) { + return !!commandLine.options.all ? + ts.sort(ts.optionDeclarations, function (a, b) { return ts.compareStringsCaseInsensitive(a.name, b.name); }) : + ts.filter(ts.optionDeclarations.slice(), function (v) { return !!v.showInSimplifiedHelpView; }); + } + function printVersion(sys) { + sys.write(ts.getDiagnosticText(ts.Diagnostics.Version_0, ts.version) + sys.newLine); + } + function printHelp(sys, optionsList, syntaxPrefix) { + if (syntaxPrefix === void 0) { syntaxPrefix = ""; } + var output = []; + var syntaxLength = ts.getDiagnosticText(ts.Diagnostics.Syntax_Colon_0, "").length; + var examplesLength = ts.getDiagnosticText(ts.Diagnostics.Examples_Colon_0, "").length; + var marginLength = Math.max(syntaxLength, examplesLength); + var syntax = makePadding(marginLength - syntaxLength); + syntax += "tsc " + syntaxPrefix + "[" + ts.getDiagnosticText(ts.Diagnostics.options) + "] [" + ts.getDiagnosticText(ts.Diagnostics.file) + "...]"; + output.push(ts.getDiagnosticText(ts.Diagnostics.Syntax_Colon_0, syntax)); + output.push(sys.newLine + sys.newLine); + var padding = makePadding(marginLength); + output.push(ts.getDiagnosticText(ts.Diagnostics.Examples_Colon_0, makePadding(marginLength - examplesLength) + "tsc hello.ts") + sys.newLine); + output.push(padding + "tsc --outFile file.js file.ts" + sys.newLine); + output.push(padding + "tsc @args.txt" + sys.newLine); + output.push(padding + "tsc --build tsconfig.json" + sys.newLine); + output.push(sys.newLine); + output.push(ts.getDiagnosticText(ts.Diagnostics.Options_Colon) + sys.newLine); + marginLength = 0; + var usageColumn = []; + var descriptionColumn = []; + var optionsDescriptionMap = ts.createMap(); + for (var _i = 0, optionsList_1 = optionsList; _i < optionsList_1.length; _i++) { + var option = optionsList_1[_i]; + if (!option.description) { + continue; + } + var usageText_1 = " "; + if (option.shortName) { + usageText_1 += "-" + option.shortName; + usageText_1 += getParamType(option); + usageText_1 += ", "; + } + usageText_1 += "--" + option.name; + usageText_1 += getParamType(option); + usageColumn.push(usageText_1); + var description = void 0; + if (option.name === "lib") { + description = ts.getDiagnosticText(option.description); + var element = option.element; + var typeMap = element.type; + optionsDescriptionMap.set(description, ts.arrayFrom(typeMap.keys()).map(function (key) { return "'" + key + "'"; })); + } + else { + description = ts.getDiagnosticText(option.description); + } + descriptionColumn.push(description); + marginLength = Math.max(usageText_1.length, marginLength); + } + var usageText = " @<" + ts.getDiagnosticText(ts.Diagnostics.file) + ">"; + usageColumn.push(usageText); + descriptionColumn.push(ts.getDiagnosticText(ts.Diagnostics.Insert_command_line_options_and_files_from_a_file)); + marginLength = Math.max(usageText.length, marginLength); + for (var i = 0; i < usageColumn.length; i++) { + var usage = usageColumn[i]; + var description = descriptionColumn[i]; + var kindsList = optionsDescriptionMap.get(description); + output.push(usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine); + if (kindsList) { + output.push(makePadding(marginLength + 4)); + for (var _a = 0, kindsList_1 = kindsList; _a < kindsList_1.length; _a++) { + var kind = kindsList_1[_a]; + output.push(kind + " "); + } + output.push(sys.newLine); + } + } + for (var _b = 0, output_1 = output; _b < output_1.length; _b++) { + var line = output_1[_b]; + sys.write(line); + } + return; + function getParamType(option) { + if (option.paramType !== undefined) { + return " " + ts.getDiagnosticText(option.paramType); + } + return ""; + } + function makePadding(paddingLength) { + return Array(paddingLength + 1).join(" "); + } + } + function executeCommandLineWorker(sys, cb, commandLine, maxNumberOfFilesToIterateForInvalidation) { + var reportDiagnostic = ts.createDiagnosticReporter(sys); + if (commandLine.options.build) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Option_build_must_be_the_first_command_line_argument)); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + var configFileName; + if (commandLine.options.locale) { + ts.validateLocaleAndSetLanguage(commandLine.options.locale, sys, commandLine.errors); + } + if (commandLine.errors.length > 0) { + commandLine.errors.forEach(reportDiagnostic); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + if (commandLine.options.init) { + writeConfigFile(sys, reportDiagnostic, commandLine.options, commandLine.fileNames); + return sys.exit(ts.ExitStatus.Success); + } + if (commandLine.options.version) { + printVersion(sys); + return sys.exit(ts.ExitStatus.Success); + } + if (commandLine.options.help || commandLine.options.all) { + printVersion(sys); + printHelp(sys, getOptionsForHelp(commandLine)); + return sys.exit(ts.ExitStatus.Success); + } + if (commandLine.options.watch && commandLine.options.listFilesOnly) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly")); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + if (commandLine.options.project) { + if (commandLine.fileNames.length !== 0) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line)); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + var fileOrDirectory = ts.normalizePath(commandLine.options.project); + if (!fileOrDirectory || sys.directoryExists(fileOrDirectory)) { + configFileName = ts.combinePaths(fileOrDirectory, "tsconfig.json"); + if (!sys.fileExists(configFileName)) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project)); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + } + else { + configFileName = fileOrDirectory; + if (!sys.fileExists(configFileName)) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project)); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + } + } + else if (commandLine.fileNames.length === 0) { + var searchPath = ts.normalizePath(sys.getCurrentDirectory()); + configFileName = ts.findConfigFile(searchPath, function (fileName) { return sys.fileExists(fileName); }); + } + if (commandLine.fileNames.length === 0 && !configFileName) { + if (commandLine.options.showConfig) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, ts.normalizePath(sys.getCurrentDirectory()))); + } + else { + printVersion(sys); + printHelp(sys, getOptionsForHelp(commandLine)); + } + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + var currentDirectory = sys.getCurrentDirectory(); + var commandLineOptions = ts.convertToOptionsWithAbsolutePaths(commandLine.options, function (fileName) { return ts.getNormalizedAbsolutePath(fileName, currentDirectory); }); + if (configFileName) { + var configParseResult = ts.parseConfigFileWithSystem(configFileName, commandLineOptions, commandLine.watchOptions, sys, reportDiagnostic); + if (commandLineOptions.showConfig) { + if (configParseResult.errors.length !== 0) { + reportDiagnostic = updateReportDiagnostic(sys, reportDiagnostic, configParseResult.options); + configParseResult.errors.forEach(reportDiagnostic); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + sys.write(JSON.stringify(ts.convertToTSConfig(configParseResult, configFileName, sys), null, 4) + sys.newLine); + return sys.exit(ts.ExitStatus.Success); + } + reportDiagnostic = updateReportDiagnostic(sys, reportDiagnostic, configParseResult.options); + if (ts.isWatchSet(configParseResult.options)) { + if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) + return; + return createWatchOfConfigFile(sys, cb, reportDiagnostic, configParseResult, commandLineOptions, commandLine.watchOptions, maxNumberOfFilesToIterateForInvalidation); + } + else if (ts.isIncrementalCompilation(configParseResult.options)) { + performIncrementalCompilation(sys, cb, reportDiagnostic, configParseResult); + } + else { + performCompilation(sys, cb, reportDiagnostic, configParseResult); + } + } + else { + if (commandLineOptions.showConfig) { + sys.write(JSON.stringify(ts.convertToTSConfig(commandLine, ts.combinePaths(currentDirectory, "tsconfig.json"), sys), null, 4) + sys.newLine); + return sys.exit(ts.ExitStatus.Success); + } + reportDiagnostic = updateReportDiagnostic(sys, reportDiagnostic, commandLineOptions); + if (ts.isWatchSet(commandLineOptions)) { + if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) + return; + return createWatchOfFilesAndCompilerOptions(sys, cb, reportDiagnostic, commandLine.fileNames, commandLineOptions, commandLine.watchOptions, maxNumberOfFilesToIterateForInvalidation); + } + else if (ts.isIncrementalCompilation(commandLineOptions)) { + performIncrementalCompilation(sys, cb, reportDiagnostic, __assign(__assign({}, commandLine), { options: commandLineOptions })); + } + else { + performCompilation(sys, cb, reportDiagnostic, __assign(__assign({}, commandLine), { options: commandLineOptions })); + } + } + } + function isBuild(commandLineArgs) { + if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === 45) { + var firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === 45 ? 2 : 1).toLowerCase(); + return firstOption === "build" || firstOption === "b"; + } + return false; + } + ts.isBuild = isBuild; + function executeCommandLine(system, cb, commandLineArgs, maxNumberOfFilesToIterateForInvalidation) { + if (isBuild(commandLineArgs)) { + var _a = ts.parseBuildCommand(commandLineArgs.slice(1)), buildOptions_1 = _a.buildOptions, watchOptions_1 = _a.watchOptions, projects_1 = _a.projects, errors_1 = _a.errors; + if (buildOptions_1.generateCpuProfile && system.enableCPUProfiler) { + system.enableCPUProfiler(buildOptions_1.generateCpuProfile, function () { return performBuild(system, cb, buildOptions_1, watchOptions_1, projects_1, errors_1); }); + } + else { + return performBuild(system, cb, buildOptions_1, watchOptions_1, projects_1, errors_1); + } + } + var commandLine = ts.parseCommandLine(commandLineArgs, function (path) { return system.readFile(path); }); + if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) { + system.enableCPUProfiler(commandLine.options.generateCpuProfile, function () { return executeCommandLineWorker(system, cb, commandLine, maxNumberOfFilesToIterateForInvalidation); }); + } + else { + return executeCommandLineWorker(system, cb, commandLine, maxNumberOfFilesToIterateForInvalidation); + } + } + ts.executeCommandLine = executeCommandLine; + function reportWatchModeWithoutSysSupport(sys, reportDiagnostic) { + if (!sys.watchFile || !sys.watchDirectory) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--watch")); + sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + return true; + } + return false; + } + function performBuild(sys, cb, buildOptions, watchOptions, projects, errors) { + var reportDiagnostic = updateReportDiagnostic(sys, ts.createDiagnosticReporter(sys), buildOptions); + if (buildOptions.locale) { + ts.validateLocaleAndSetLanguage(buildOptions.locale, sys, errors); + } + if (errors.length > 0) { + errors.forEach(reportDiagnostic); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + if (buildOptions.help) { + printVersion(sys); + printHelp(sys, ts.buildOpts, "--build "); + return sys.exit(ts.ExitStatus.Success); + } + if (projects.length === 0) { + printVersion(sys); + printHelp(sys, ts.buildOpts, "--build "); + return sys.exit(ts.ExitStatus.Success); + } + if (!sys.getModifiedTime || !sys.setModifiedTime || (buildOptions.clean && !sys.deleteFile)) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--build")); + return sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + if (buildOptions.watch) { + if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) + return; + var buildHost_1 = ts.createSolutionBuilderWithWatchHost(sys, undefined, reportDiagnostic, ts.createBuilderStatusReporter(sys, shouldBePretty(sys, buildOptions)), createWatchStatusReporter(sys, buildOptions)); + updateSolutionBuilderHost(sys, cb, buildHost_1); + var builder_1 = ts.createSolutionBuilderWithWatch(buildHost_1, projects, buildOptions, watchOptions); + builder_1.build(); + return builder_1; + } + var buildHost = ts.createSolutionBuilderHost(sys, undefined, reportDiagnostic, ts.createBuilderStatusReporter(sys, shouldBePretty(sys, buildOptions)), createReportErrorSummary(sys, buildOptions)); + updateSolutionBuilderHost(sys, cb, buildHost); + var builder = ts.createSolutionBuilder(buildHost, projects, buildOptions); + var exitStatus = buildOptions.clean ? builder.clean() : builder.build(); + return sys.exit(exitStatus); + } + function createReportErrorSummary(sys, options) { + return shouldBePretty(sys, options) ? + function (errorCount) { return sys.write(ts.getErrorSummaryText(errorCount, sys.newLine)); } : + undefined; + } + function performCompilation(sys, cb, reportDiagnostic, config) { + var fileNames = config.fileNames, options = config.options, projectReferences = config.projectReferences; + var host = ts.createCompilerHostWorker(options, undefined, sys); + var currentDirectory = host.getCurrentDirectory(); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, currentDirectory, getCanonicalFileName); }); + enableStatistics(sys, options); + var programOptions = { + rootNames: fileNames, + options: options, + projectReferences: projectReferences, + host: host, + configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(config) + }; + var program = ts.createProgram(programOptions); + var exitStatus = ts.emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, function (s) { return sys.write(s + sys.newLine); }, createReportErrorSummary(sys, options)); + reportStatistics(sys, program); + cb(program); + return sys.exit(exitStatus); + } + function performIncrementalCompilation(sys, cb, reportDiagnostic, config) { + var options = config.options, fileNames = config.fileNames, projectReferences = config.projectReferences; + enableStatistics(sys, options); + var host = ts.createIncrementalCompilerHost(options, sys); + var exitStatus = ts.performIncrementalCompilation({ + host: host, + system: sys, + rootNames: fileNames, + options: options, + configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(config), + projectReferences: projectReferences, + reportDiagnostic: reportDiagnostic, + reportErrorSummary: createReportErrorSummary(sys, options), + afterProgramEmitAndDiagnostics: function (builderProgram) { + reportStatistics(sys, builderProgram.getProgram()); + cb(builderProgram); + } + }); + return sys.exit(exitStatus); + } + function updateSolutionBuilderHost(sys, cb, buildHost) { + updateCreateProgram(sys, buildHost); + buildHost.afterProgramEmitAndDiagnostics = function (program) { + reportStatistics(sys, program.getProgram()); + cb(program); + }; + buildHost.afterEmitBundle = cb; + } + function updateCreateProgram(sys, host) { + var compileUsingBuilder = host.createProgram; + host.createProgram = function (rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences) { + ts.Debug.assert(rootNames !== undefined || (options === undefined && !!oldProgram)); + if (options !== undefined) { + enableStatistics(sys, options); + } + return compileUsingBuilder(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences); + }; + } + function updateWatchCompilationHost(sys, cb, watchCompilerHost, maxNumberOfFilesToIterateForInvalidation) { + updateCreateProgram(sys, watchCompilerHost); + watchCompilerHost.maxNumberOfFilesToIterateForInvalidation = maxNumberOfFilesToIterateForInvalidation; + var emitFilesUsingBuilder = watchCompilerHost.afterProgramCreate; + watchCompilerHost.afterProgramCreate = function (builderProgram) { + emitFilesUsingBuilder(builderProgram); + reportStatistics(sys, builderProgram.getProgram()); + cb(builderProgram); + }; + } + function createWatchStatusReporter(sys, options) { + return ts.createWatchStatusReporter(sys, shouldBePretty(sys, options)); + } + function createWatchOfConfigFile(sys, cb, reportDiagnostic, configParseResult, optionsToExtend, watchOptionsToExtend, maxNumberOfFilesToIterateForInvalidation) { + var watchCompilerHost = ts.createWatchCompilerHostOfConfigFile(configParseResult.options.configFilePath, optionsToExtend, watchOptionsToExtend, sys, undefined, reportDiagnostic, createWatchStatusReporter(sys, configParseResult.options)); + updateWatchCompilationHost(sys, cb, watchCompilerHost, maxNumberOfFilesToIterateForInvalidation); + watchCompilerHost.configFileParsingResult = configParseResult; + return ts.createWatchProgram(watchCompilerHost); + } + function createWatchOfFilesAndCompilerOptions(sys, cb, reportDiagnostic, rootFiles, options, watchOptions, maxNumberOfFilesToIterateForInvalidation) { + var watchCompilerHost = ts.createWatchCompilerHostOfFilesAndCompilerOptions(rootFiles, options, watchOptions, sys, undefined, reportDiagnostic, createWatchStatusReporter(sys, options)); + updateWatchCompilationHost(sys, cb, watchCompilerHost, maxNumberOfFilesToIterateForInvalidation); + return ts.createWatchProgram(watchCompilerHost); + } + function canReportDiagnostics(system, compilerOptions) { + return system === ts.sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics); + } + function enableStatistics(sys, compilerOptions) { + if (canReportDiagnostics(sys, compilerOptions)) { + ts.performance.enable(); + } + } + function reportStatistics(sys, program) { + var statistics; + var compilerOptions = program.getCompilerOptions(); + if (canReportDiagnostics(sys, compilerOptions)) { + statistics = []; + var memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1; + reportCountStatistic("Files", program.getSourceFiles().length); + reportCountStatistic("Lines", countLines(program)); + reportCountStatistic("Nodes", program.getNodeCount()); + reportCountStatistic("Identifiers", program.getIdentifierCount()); + reportCountStatistic("Symbols", program.getSymbolCount()); + reportCountStatistic("Types", program.getTypeCount()); + if (memoryUsed >= 0) { + reportStatisticalValue("Memory used", Math.round(memoryUsed / 1000) + "K"); + } + var programTime = ts.performance.getDuration("Program"); + var bindTime = ts.performance.getDuration("Bind"); + var checkTime = ts.performance.getDuration("Check"); + var emitTime = ts.performance.getDuration("Emit"); + if (compilerOptions.extendedDiagnostics) { + var caches = program.getRelationCacheSizes(); + reportCountStatistic("Assignability cache size", caches.assignable); + reportCountStatistic("Identity cache size", caches.identity); + reportCountStatistic("Subtype cache size", caches.subtype); + reportCountStatistic("Strict subtype cache size", caches.strictSubtype); + ts.performance.forEachMeasure(function (name, duration) { return reportTimeStatistic(name + " time", duration); }); + } + else { + reportTimeStatistic("I/O read", ts.performance.getDuration("I/O Read")); + reportTimeStatistic("I/O write", ts.performance.getDuration("I/O Write")); + reportTimeStatistic("Parse time", programTime); + reportTimeStatistic("Bind time", bindTime); + reportTimeStatistic("Check time", checkTime); + reportTimeStatistic("Emit time", emitTime); + } + reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime); + reportStatistics(); + ts.performance.disable(); + } + function reportStatistics() { + var nameSize = 0; + var valueSize = 0; + for (var _i = 0, statistics_1 = statistics; _i < statistics_1.length; _i++) { + var _a = statistics_1[_i], name = _a.name, value = _a.value; + if (name.length > nameSize) { + nameSize = name.length; + } + if (value.length > valueSize) { + valueSize = value.length; + } + } + for (var _b = 0, statistics_2 = statistics; _b < statistics_2.length; _b++) { + var _c = statistics_2[_b], name = _c.name, value = _c.value; + sys.write(padRight(name + ":", nameSize + 2) + padLeft(value.toString(), valueSize) + sys.newLine); + } + } + function reportStatisticalValue(name, value) { + statistics.push({ name: name, value: value }); + } + function reportCountStatistic(name, count) { + reportStatisticalValue(name, "" + count); + } + function reportTimeStatistic(name, time) { + reportStatisticalValue(name, (time / 1000).toFixed(2) + "s"); + } + } + function writeConfigFile(sys, reportDiagnostic, options, fileNames) { + var currentDirectory = sys.getCurrentDirectory(); + var file = ts.normalizePath(ts.combinePaths(currentDirectory, "tsconfig.json")); + if (sys.fileExists(file)) { + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file)); + } + else { + sys.writeFile(file, ts.generateTSConfig(options, fileNames, sys.newLine)); + reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Successfully_created_a_tsconfig_json_file)); + } + return; + } +})(ts || (ts = {})); +// This file actually uses arguments passed on commandline and executes it +if (ts.Debug.isDebugging) { + ts.Debug.enableDebugInfo(); +} +if (ts.sys.tryEnableSourceMapsForHost && /^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV"))) { + ts.sys.tryEnableSourceMapsForHost(); +} +if (ts.sys.setBlocking) { + ts.sys.setBlocking(); +} +ts.executeCommandLine(ts.sys, ts.noop, ts.sys.args); diff --git a/package.json b/package.json index 609dc09e..b6a09fb5 100644 --- a/package.json +++ b/package.json @@ -6,6 +6,7 @@ "module": "./esm/index.js", "jsnext:main": "./next/index.js", "typings": "./lib/index.d.ts", + "bin": "./bin/ttsc", "scripts": { "build": "yarn build:cjs && yarn build:esm && yarn build:next", "build:cjs": "shx rm -rf lib && tsc -p src/tsconfig.json", diff --git a/postinstall.js b/postinstall.js new file mode 100644 index 00000000..d8ed4fa6 --- /dev/null +++ b/postinstall.js @@ -0,0 +1,12 @@ +const fs = require('fs') +const path = require('path') + +const tscContent = fs.readFileSync(require.resolve('typescript/lib/tsc.js'), 'utf8') +const binContent = fs.readFileSync(path.join(__dirname, 'lib', 'bin.js'), 'utf8') + +const snippet = `#!/usr/bin/env node + +${binContent} +` + +fs.writeFileSync(path.join(__dirname, 'bin', 'ttsc'), snippet + tscContent) diff --git a/src/bin.ts b/src/bin.ts new file mode 100644 index 00000000..b1a92f5a --- /dev/null +++ b/src/bin.ts @@ -0,0 +1,13 @@ +const ts = new Proxy( + {}, + { + set(obj, prop, value) { + if (prop === 'sys') { + value.getExecutingFilePath = function getExecutingFilePath() { + return require.resolve('typescript/lib/tsc.js') + } + } + return Reflect.set(obj, prop, value) + }, + }, +) diff --git a/src/tsconfig.json b/src/tsconfig.json index a7739614..5e1f0f79 100644 --- a/src/tsconfig.json +++ b/src/tsconfig.json @@ -9,6 +9,7 @@ "noUnusedParameters": true }, "files": [ - "./index.ts" + "./index.ts", + "./bin.ts" ] } \ No newline at end of file