+ };
+ }
+ ts.helperString = helperString;
+ 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 };"
+ };
+ 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 };"
+ };
+ 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.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 };"
+ };
+ 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); }"
+ };
+ ts.asyncGeneratorHelper = {
+ name: "typescript:asyncGenerator",
+ importName: "__asyncGenerator",
+ scoped: false,
+ dependencies: [ts.awaitHelper],
+ 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 };"
+ };
+ ts.asyncDelegator = {
+ name: "typescript:asyncDelegator",
+ importName: "__asyncDelegator",
+ scoped: false,
+ dependencies: [ts.awaitHelper],
+ 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 };"
+ };
+ 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 };"
+ };
+ 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 };"
+ };
+ 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 };"
+ };
+ 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 (Object.prototype.hasOwnProperty.call(b, 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.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 };"
+ };
+ ts.spreadHelper = {
+ name: "typescript:spread",
+ importName: "__spread",
+ scoped: false,
+ dependencies: [ts.readHelper],
+ 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 };"
+ };
+ 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 };"
+ };
+ 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 };"
+ };
+ 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.createBindingHelper = {
+ name: "typescript:commonjscreatebinding",
+ importName: "__createBinding",
+ scoped: false,
+ priority: 1,
+ text: "\n var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n }) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n }));"
+ };
+ ts.setModuleDefaultHelper = {
+ name: "typescript:commonjscreatevalue",
+ importName: "__setModuleDefault",
+ scoped: false,
+ priority: 1,
+ text: "\n var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n }) : function(o, v) {\n o[\"default\"] = v;\n });"
+ };
+ ts.importStarHelper = {
+ name: "typescript:commonjsimportstar",
+ importName: "__importStar",
+ scoped: false,
+ dependencies: [ts.createBindingHelper, ts.setModuleDefaultHelper],
+ priority: 2,
+ text: "\n var __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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n };"
+ };
+ ts.importDefaultHelper = {
+ name: "typescript:commonjsimportdefault",
+ importName: "__importDefault",
+ scoped: false,
+ text: "\n var __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n };"
+ };
+ ts.exportStarHelper = {
+ name: "typescript:export-star",
+ importName: "__exportStar",
+ scoped: false,
+ dependencies: [ts.createBindingHelper],
+ priority: 2,
+ text: "\n var __exportStar = (this && this.__exportStar) || function(m, exports) {\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n };"
+ };
+ ts.classPrivateFieldGetHelper = {
+ name: "typescript:classPrivateFieldGet",
+ importName: "__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 };"
+ };
+ ts.classPrivateFieldSetHelper = {
+ name: "typescript:classPrivateFieldSet",
+ importName: "__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 };"
+ };
+ var allUnscopedEmitHelpers;
+ function getAllUnscopedEmitHelpers() {
+ return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([
+ ts.decorateHelper,
+ ts.metadataHelper,
+ ts.paramHelper,
+ ts.assignHelper,
+ ts.awaitHelper,
+ ts.asyncGeneratorHelper,
+ ts.asyncDelegator,
+ ts.asyncValues,
+ ts.restHelper,
+ ts.awaiterHelper,
+ ts.extendsHelper,
+ ts.templateObjectHelper,
+ ts.spreadHelper,
+ ts.spreadArraysHelper,
+ ts.valuesHelper,
+ ts.readHelper,
+ ts.generatorHelper,
+ ts.importStarHelper,
+ ts.importDefaultHelper,
+ ts.exportStarHelper,
+ ts.classPrivateFieldGetHelper,
+ ts.classPrivateFieldSetHelper,
+ ts.createBindingHelper,
+ ts.setModuleDefaultHelper
+ ], function (helper) { return helper.name; }));
+ }
+ ts.getAllUnscopedEmitHelpers = getAllUnscopedEmitHelpers;
+ ts.asyncSuperHelper = {
+ name: "typescript:async-super",
+ scoped: true,
+ text: helperString(__makeTemplateObject(["\n const ", " = name => super[name];"], ["\n const ", " = name => super[name];"]), "_superIndex")
+ };
+ ts.advancedAsyncSuperHelper = {
+ name: "typescript:advanced-async-super",
+ scoped: true,
+ text: 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 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 === 78;
+ }
+ ts.isIdentifier = isIdentifier;
+ function isQualifiedName(node) {
+ return node.kind === 157;
+ }
+ ts.isQualifiedName = isQualifiedName;
+ function isComputedPropertyName(node) {
+ return node.kind === 158;
+ }
+ ts.isComputedPropertyName = isComputedPropertyName;
+ function isPrivateIdentifier(node) {
+ return node.kind === 79;
+ }
+ ts.isPrivateIdentifier = isPrivateIdentifier;
+ function isSuperKeyword(node) {
+ return node.kind === 105;
+ }
+ ts.isSuperKeyword = isSuperKeyword;
+ function isImportKeyword(node) {
+ return node.kind === 99;
+ }
+ ts.isImportKeyword = isImportKeyword;
+ function isCommaToken(node) {
+ return node.kind === 27;
+ }
+ ts.isCommaToken = isCommaToken;
+ function isQuestionToken(node) {
+ return node.kind === 57;
+ }
+ ts.isQuestionToken = isQuestionToken;
+ function isExclamationToken(node) {
+ return node.kind === 53;
+ }
+ ts.isExclamationToken = isExclamationToken;
+ function isTypeParameterDeclaration(node) {
+ return node.kind === 159;
+ }
+ ts.isTypeParameterDeclaration = isTypeParameterDeclaration;
+ function isParameter(node) {
+ return node.kind === 160;
+ }
+ ts.isParameter = isParameter;
+ function isDecorator(node) {
+ return node.kind === 161;
+ }
+ ts.isDecorator = isDecorator;
+ function isPropertySignature(node) {
+ return node.kind === 162;
+ }
+ ts.isPropertySignature = isPropertySignature;
+ function isPropertyDeclaration(node) {
+ return node.kind === 163;
+ }
+ ts.isPropertyDeclaration = isPropertyDeclaration;
+ function isMethodSignature(node) {
+ return node.kind === 164;
+ }
+ ts.isMethodSignature = isMethodSignature;
+ function isMethodDeclaration(node) {
+ return node.kind === 165;
+ }
+ ts.isMethodDeclaration = isMethodDeclaration;
+ function isConstructorDeclaration(node) {
+ return node.kind === 166;
+ }
+ ts.isConstructorDeclaration = isConstructorDeclaration;
+ function isGetAccessorDeclaration(node) {
+ return node.kind === 167;
+ }
+ ts.isGetAccessorDeclaration = isGetAccessorDeclaration;
+ function isSetAccessorDeclaration(node) {
+ return node.kind === 168;
+ }
+ ts.isSetAccessorDeclaration = isSetAccessorDeclaration;
+ function isCallSignatureDeclaration(node) {
+ return node.kind === 169;
+ }
+ ts.isCallSignatureDeclaration = isCallSignatureDeclaration;
+ function isConstructSignatureDeclaration(node) {
+ return node.kind === 170;
+ }
+ ts.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
+ function isIndexSignatureDeclaration(node) {
+ return node.kind === 171;
+ }
+ ts.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
+ function isTypePredicateNode(node) {
+ return node.kind === 172;
+ }
+ ts.isTypePredicateNode = isTypePredicateNode;
+ function isTypeReferenceNode(node) {
+ return node.kind === 173;
+ }
+ ts.isTypeReferenceNode = isTypeReferenceNode;
+ function isFunctionTypeNode(node) {
+ return node.kind === 174;
+ }
+ ts.isFunctionTypeNode = isFunctionTypeNode;
+ function isConstructorTypeNode(node) {
+ return node.kind === 175;
+ }
+ ts.isConstructorTypeNode = isConstructorTypeNode;
+ function isTypeQueryNode(node) {
+ return node.kind === 176;
+ }
+ ts.isTypeQueryNode = isTypeQueryNode;
+ function isTypeLiteralNode(node) {
+ return node.kind === 177;
+ }
+ ts.isTypeLiteralNode = isTypeLiteralNode;
+ function isArrayTypeNode(node) {
+ return node.kind === 178;
+ }
+ ts.isArrayTypeNode = isArrayTypeNode;
+ function isTupleTypeNode(node) {
+ return node.kind === 179;
+ }
+ ts.isTupleTypeNode = isTupleTypeNode;
+ function isNamedTupleMember(node) {
+ return node.kind === 192;
+ }
+ ts.isNamedTupleMember = isNamedTupleMember;
+ function isOptionalTypeNode(node) {
+ return node.kind === 180;
+ }
+ ts.isOptionalTypeNode = isOptionalTypeNode;
+ function isRestTypeNode(node) {
+ return node.kind === 181;
+ }
+ ts.isRestTypeNode = isRestTypeNode;
+ function isUnionTypeNode(node) {
+ return node.kind === 182;
+ }
+ ts.isUnionTypeNode = isUnionTypeNode;
+ function isIntersectionTypeNode(node) {
+ return node.kind === 183;
+ }
+ ts.isIntersectionTypeNode = isIntersectionTypeNode;
+ function isConditionalTypeNode(node) {
+ return node.kind === 184;
+ }
+ ts.isConditionalTypeNode = isConditionalTypeNode;
+ function isInferTypeNode(node) {
+ return node.kind === 185;
+ }
+ ts.isInferTypeNode = isInferTypeNode;
+ function isParenthesizedTypeNode(node) {
+ return node.kind === 186;
+ }
+ ts.isParenthesizedTypeNode = isParenthesizedTypeNode;
+ function isThisTypeNode(node) {
+ return node.kind === 187;
+ }
+ ts.isThisTypeNode = isThisTypeNode;
+ function isTypeOperatorNode(node) {
+ return node.kind === 188;
+ }
+ ts.isTypeOperatorNode = isTypeOperatorNode;
+ function isIndexedAccessTypeNode(node) {
+ return node.kind === 189;
+ }
+ ts.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
+ function isMappedTypeNode(node) {
+ return node.kind === 190;
+ }
+ ts.isMappedTypeNode = isMappedTypeNode;
+ function isLiteralTypeNode(node) {
+ return node.kind === 191;
+ }
+ ts.isLiteralTypeNode = isLiteralTypeNode;
+ function isImportTypeNode(node) {
+ return node.kind === 195;
+ }
+ ts.isImportTypeNode = isImportTypeNode;
+ function isTemplateLiteralTypeSpan(node) {
+ return node.kind === 194;
+ }
+ ts.isTemplateLiteralTypeSpan = isTemplateLiteralTypeSpan;
+ function isTemplateLiteralTypeNode(node) {
+ return node.kind === 193;
+ }
+ ts.isTemplateLiteralTypeNode = isTemplateLiteralTypeNode;
+ function isObjectBindingPattern(node) {
+ return node.kind === 196;
+ }
+ ts.isObjectBindingPattern = isObjectBindingPattern;
+ function isArrayBindingPattern(node) {
+ return node.kind === 197;
+ }
+ ts.isArrayBindingPattern = isArrayBindingPattern;
+ function isBindingElement(node) {
+ return node.kind === 198;
+ }
+ ts.isBindingElement = isBindingElement;
+ function isArrayLiteralExpression(node) {
+ return node.kind === 199;
+ }
+ ts.isArrayLiteralExpression = isArrayLiteralExpression;
+ function isObjectLiteralExpression(node) {
+ return node.kind === 200;
+ }
+ ts.isObjectLiteralExpression = isObjectLiteralExpression;
+ function isPropertyAccessExpression(node) {
+ return node.kind === 201;
+ }
+ ts.isPropertyAccessExpression = isPropertyAccessExpression;
+ function isElementAccessExpression(node) {
+ return node.kind === 202;
+ }
+ ts.isElementAccessExpression = isElementAccessExpression;
+ function isCallExpression(node) {
+ return node.kind === 203;
+ }
+ ts.isCallExpression = isCallExpression;
+ function isNewExpression(node) {
+ return node.kind === 204;
+ }
+ ts.isNewExpression = isNewExpression;
+ function isTaggedTemplateExpression(node) {
+ return node.kind === 205;
+ }
+ ts.isTaggedTemplateExpression = isTaggedTemplateExpression;
+ function isTypeAssertionExpression(node) {
+ return node.kind === 206;
+ }
+ ts.isTypeAssertionExpression = isTypeAssertionExpression;
+ function isParenthesizedExpression(node) {
+ return node.kind === 207;
+ }
+ ts.isParenthesizedExpression = isParenthesizedExpression;
+ function isFunctionExpression(node) {
+ return node.kind === 208;
+ }
+ ts.isFunctionExpression = isFunctionExpression;
+ function isArrowFunction(node) {
+ return node.kind === 209;
+ }
+ ts.isArrowFunction = isArrowFunction;
+ function isDeleteExpression(node) {
+ return node.kind === 210;
+ }
+ ts.isDeleteExpression = isDeleteExpression;
+ function isTypeOfExpression(node) {
+ return node.kind === 211;
+ }
+ ts.isTypeOfExpression = isTypeOfExpression;
+ function isVoidExpression(node) {
+ return node.kind === 212;
+ }
+ ts.isVoidExpression = isVoidExpression;
+ function isAwaitExpression(node) {
+ return node.kind === 213;
+ }
+ ts.isAwaitExpression = isAwaitExpression;
+ function isPrefixUnaryExpression(node) {
+ return node.kind === 214;
+ }
+ ts.isPrefixUnaryExpression = isPrefixUnaryExpression;
+ function isPostfixUnaryExpression(node) {
+ return node.kind === 215;
+ }
+ ts.isPostfixUnaryExpression = isPostfixUnaryExpression;
+ function isBinaryExpression(node) {
+ return node.kind === 216;
+ }
+ ts.isBinaryExpression = isBinaryExpression;
+ function isConditionalExpression(node) {
+ return node.kind === 217;
+ }
+ ts.isConditionalExpression = isConditionalExpression;
+ function isTemplateExpression(node) {
+ return node.kind === 218;
+ }
+ ts.isTemplateExpression = isTemplateExpression;
+ function isYieldExpression(node) {
+ return node.kind === 219;
+ }
+ ts.isYieldExpression = isYieldExpression;
+ function isSpreadElement(node) {
+ return node.kind === 220;
+ }
+ ts.isSpreadElement = isSpreadElement;
+ function isClassExpression(node) {
+ return node.kind === 221;
+ }
+ ts.isClassExpression = isClassExpression;
+ function isOmittedExpression(node) {
+ return node.kind === 222;
+ }
+ ts.isOmittedExpression = isOmittedExpression;
+ function isExpressionWithTypeArguments(node) {
+ return node.kind === 223;
+ }
+ ts.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
+ function isAsExpression(node) {
+ return node.kind === 224;
+ }
+ ts.isAsExpression = isAsExpression;
+ function isNonNullExpression(node) {
+ return node.kind === 225;
+ }
+ ts.isNonNullExpression = isNonNullExpression;
+ function isMetaProperty(node) {
+ return node.kind === 226;
+ }
+ ts.isMetaProperty = isMetaProperty;
+ function isSyntheticExpression(node) {
+ return node.kind === 227;
+ }
+ ts.isSyntheticExpression = isSyntheticExpression;
+ function isPartiallyEmittedExpression(node) {
+ return node.kind === 336;
+ }
+ ts.isPartiallyEmittedExpression = isPartiallyEmittedExpression;
+ function isCommaListExpression(node) {
+ return node.kind === 337;
+ }
+ ts.isCommaListExpression = isCommaListExpression;
+ function isTemplateSpan(node) {
+ return node.kind === 228;
+ }
+ ts.isTemplateSpan = isTemplateSpan;
+ function isSemicolonClassElement(node) {
+ return node.kind === 229;
+ }
+ ts.isSemicolonClassElement = isSemicolonClassElement;
+ function isBlock(node) {
+ return node.kind === 230;
+ }
+ ts.isBlock = isBlock;
+ function isVariableStatement(node) {
+ return node.kind === 232;
+ }
+ ts.isVariableStatement = isVariableStatement;
+ function isEmptyStatement(node) {
+ return node.kind === 231;
+ }
+ ts.isEmptyStatement = isEmptyStatement;
+ function isExpressionStatement(node) {
+ return node.kind === 233;
+ }
+ ts.isExpressionStatement = isExpressionStatement;
+ function isIfStatement(node) {
+ return node.kind === 234;
+ }
+ ts.isIfStatement = isIfStatement;
+ function isDoStatement(node) {
+ return node.kind === 235;
+ }
+ ts.isDoStatement = isDoStatement;
+ function isWhileStatement(node) {
+ return node.kind === 236;
+ }
+ ts.isWhileStatement = isWhileStatement;
+ function isForStatement(node) {
+ return node.kind === 237;
+ }
+ ts.isForStatement = isForStatement;
+ function isForInStatement(node) {
+ return node.kind === 238;
+ }
+ ts.isForInStatement = isForInStatement;
+ function isForOfStatement(node) {
+ return node.kind === 239;
+ }
+ ts.isForOfStatement = isForOfStatement;
+ function isContinueStatement(node) {
+ return node.kind === 240;
+ }
+ ts.isContinueStatement = isContinueStatement;
+ function isBreakStatement(node) {
+ return node.kind === 241;
+ }
+ ts.isBreakStatement = isBreakStatement;
+ function isReturnStatement(node) {
+ return node.kind === 242;
+ }
+ ts.isReturnStatement = isReturnStatement;
+ function isWithStatement(node) {
+ return node.kind === 243;
+ }
+ ts.isWithStatement = isWithStatement;
+ function isSwitchStatement(node) {
+ return node.kind === 244;
+ }
+ ts.isSwitchStatement = isSwitchStatement;
+ function isLabeledStatement(node) {
+ return node.kind === 245;
+ }
+ ts.isLabeledStatement = isLabeledStatement;
+ function isThrowStatement(node) {
+ return node.kind === 246;
+ }
+ ts.isThrowStatement = isThrowStatement;
+ function isTryStatement(node) {
+ return node.kind === 247;
+ }
+ ts.isTryStatement = isTryStatement;
+ function isDebuggerStatement(node) {
+ return node.kind === 248;
+ }
+ ts.isDebuggerStatement = isDebuggerStatement;
+ function isVariableDeclaration(node) {
+ return node.kind === 249;
+ }
+ ts.isVariableDeclaration = isVariableDeclaration;
+ function isVariableDeclarationList(node) {
+ return node.kind === 250;
+ }
+ ts.isVariableDeclarationList = isVariableDeclarationList;
+ function isFunctionDeclaration(node) {
+ return node.kind === 251;
+ }
+ ts.isFunctionDeclaration = isFunctionDeclaration;
+ function isClassDeclaration(node) {
+ return node.kind === 252;
+ }
+ ts.isClassDeclaration = isClassDeclaration;
+ function isInterfaceDeclaration(node) {
+ return node.kind === 253;
+ }
+ ts.isInterfaceDeclaration = isInterfaceDeclaration;
+ function isTypeAliasDeclaration(node) {
+ return node.kind === 254;
+ }
+ ts.isTypeAliasDeclaration = isTypeAliasDeclaration;
+ function isEnumDeclaration(node) {
+ return node.kind === 255;
+ }
+ ts.isEnumDeclaration = isEnumDeclaration;
+ function isModuleDeclaration(node) {
+ return node.kind === 256;
+ }
+ ts.isModuleDeclaration = isModuleDeclaration;
+ function isModuleBlock(node) {
+ return node.kind === 257;
+ }
+ ts.isModuleBlock = isModuleBlock;
+ function isCaseBlock(node) {
+ return node.kind === 258;
+ }
+ ts.isCaseBlock = isCaseBlock;
+ function isNamespaceExportDeclaration(node) {
+ return node.kind === 259;
+ }
+ ts.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
+ function isImportEqualsDeclaration(node) {
+ return node.kind === 260;
+ }
+ ts.isImportEqualsDeclaration = isImportEqualsDeclaration;
+ function isImportDeclaration(node) {
+ return node.kind === 261;
+ }
+ ts.isImportDeclaration = isImportDeclaration;
+ function isImportClause(node) {
+ return node.kind === 262;
+ }
+ ts.isImportClause = isImportClause;
+ function isNamespaceImport(node) {
+ return node.kind === 263;
+ }
+ ts.isNamespaceImport = isNamespaceImport;
+ function isNamespaceExport(node) {
+ return node.kind === 269;
+ }
+ ts.isNamespaceExport = isNamespaceExport;
+ function isNamedImports(node) {
+ return node.kind === 264;
+ }
+ ts.isNamedImports = isNamedImports;
+ function isImportSpecifier(node) {
+ return node.kind === 265;
+ }
+ ts.isImportSpecifier = isImportSpecifier;
+ function isExportAssignment(node) {
+ return node.kind === 266;
+ }
+ ts.isExportAssignment = isExportAssignment;
+ function isExportDeclaration(node) {
+ return node.kind === 267;
+ }
+ ts.isExportDeclaration = isExportDeclaration;
+ function isNamedExports(node) {
+ return node.kind === 268;
+ }
+ ts.isNamedExports = isNamedExports;
+ function isExportSpecifier(node) {
+ return node.kind === 270;
+ }
+ ts.isExportSpecifier = isExportSpecifier;
+ function isMissingDeclaration(node) {
+ return node.kind === 271;
+ }
+ ts.isMissingDeclaration = isMissingDeclaration;
+ function isNotEmittedStatement(node) {
+ return node.kind === 335;
+ }
+ ts.isNotEmittedStatement = isNotEmittedStatement;
+ function isSyntheticReference(node) {
+ return node.kind === 340;
+ }
+ ts.isSyntheticReference = isSyntheticReference;
+ function isMergeDeclarationMarker(node) {
+ return node.kind === 338;
+ }
+ ts.isMergeDeclarationMarker = isMergeDeclarationMarker;
+ function isEndOfDeclarationMarker(node) {
+ return node.kind === 339;
+ }
+ ts.isEndOfDeclarationMarker = isEndOfDeclarationMarker;
+ function isExternalModuleReference(node) {
+ return node.kind === 272;
+ }
+ ts.isExternalModuleReference = isExternalModuleReference;
+ function isJsxElement(node) {
+ return node.kind === 273;
+ }
+ ts.isJsxElement = isJsxElement;
+ function isJsxSelfClosingElement(node) {
+ return node.kind === 274;
+ }
+ ts.isJsxSelfClosingElement = isJsxSelfClosingElement;
+ function isJsxOpeningElement(node) {
+ return node.kind === 275;
+ }
+ ts.isJsxOpeningElement = isJsxOpeningElement;
+ function isJsxClosingElement(node) {
+ return node.kind === 276;
+ }
+ ts.isJsxClosingElement = isJsxClosingElement;
+ function isJsxFragment(node) {
+ return node.kind === 277;
+ }
+ ts.isJsxFragment = isJsxFragment;
+ function isJsxOpeningFragment(node) {
+ return node.kind === 278;
+ }
+ ts.isJsxOpeningFragment = isJsxOpeningFragment;
+ function isJsxClosingFragment(node) {
+ return node.kind === 279;
+ }
+ ts.isJsxClosingFragment = isJsxClosingFragment;
+ function isJsxAttribute(node) {
+ return node.kind === 280;
+ }
+ ts.isJsxAttribute = isJsxAttribute;
+ function isJsxAttributes(node) {
+ return node.kind === 281;
+ }
+ ts.isJsxAttributes = isJsxAttributes;
+ function isJsxSpreadAttribute(node) {
+ return node.kind === 282;
+ }
+ ts.isJsxSpreadAttribute = isJsxSpreadAttribute;
+ function isJsxExpression(node) {
+ return node.kind === 283;
+ }
+ ts.isJsxExpression = isJsxExpression;
+ function isCaseClause(node) {
+ return node.kind === 284;
+ }
+ ts.isCaseClause = isCaseClause;
+ function isDefaultClause(node) {
+ return node.kind === 285;
+ }
+ ts.isDefaultClause = isDefaultClause;
+ function isHeritageClause(node) {
+ return node.kind === 286;
+ }
+ ts.isHeritageClause = isHeritageClause;
+ function isCatchClause(node) {
+ return node.kind === 287;
+ }
+ ts.isCatchClause = isCatchClause;
+ function isPropertyAssignment(node) {
+ return node.kind === 288;
+ }
+ ts.isPropertyAssignment = isPropertyAssignment;
+ function isShorthandPropertyAssignment(node) {
+ return node.kind === 289;
+ }
+ ts.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
+ function isSpreadAssignment(node) {
+ return node.kind === 290;
+ }
+ ts.isSpreadAssignment = isSpreadAssignment;
+ function isEnumMember(node) {
+ return node.kind === 291;
+ }
+ ts.isEnumMember = isEnumMember;
+ function isUnparsedPrepend(node) {
+ return node.kind === 293;
+ }
+ ts.isUnparsedPrepend = isUnparsedPrepend;
+ function isSourceFile(node) {
+ return node.kind === 297;
+ }
+ ts.isSourceFile = isSourceFile;
+ function isBundle(node) {
+ return node.kind === 298;
+ }
+ ts.isBundle = isBundle;
+ function isUnparsedSource(node) {
+ return node.kind === 299;
+ }
+ ts.isUnparsedSource = isUnparsedSource;
+ function isJSDocTypeExpression(node) {
+ return node.kind === 301;
+ }
+ ts.isJSDocTypeExpression = isJSDocTypeExpression;
+ function isJSDocNameReference(node) {
+ return node.kind === 302;
+ }
+ ts.isJSDocNameReference = isJSDocNameReference;
+ function isJSDocAllType(node) {
+ return node.kind === 303;
+ }
+ ts.isJSDocAllType = isJSDocAllType;
+ function isJSDocUnknownType(node) {
+ return node.kind === 304;
+ }
+ ts.isJSDocUnknownType = isJSDocUnknownType;
+ function isJSDocNullableType(node) {
+ return node.kind === 305;
+ }
+ ts.isJSDocNullableType = isJSDocNullableType;
+ function isJSDocNonNullableType(node) {
+ return node.kind === 306;
+ }
+ ts.isJSDocNonNullableType = isJSDocNonNullableType;
+ function isJSDocOptionalType(node) {
+ return node.kind === 307;
+ }
+ ts.isJSDocOptionalType = isJSDocOptionalType;
+ function isJSDocFunctionType(node) {
+ return node.kind === 308;
+ }
+ ts.isJSDocFunctionType = isJSDocFunctionType;
+ function isJSDocVariadicType(node) {
+ return node.kind === 309;
+ }
+ ts.isJSDocVariadicType = isJSDocVariadicType;
+ function isJSDocNamepathType(node) {
+ return node.kind === 310;
+ }
+ ts.isJSDocNamepathType = isJSDocNamepathType;
+ function isJSDoc(node) {
+ return node.kind === 311;
+ }
+ ts.isJSDoc = isJSDoc;
+ function isJSDocTypeLiteral(node) {
+ return node.kind === 312;
+ }
+ ts.isJSDocTypeLiteral = isJSDocTypeLiteral;
+ function isJSDocSignature(node) {
+ return node.kind === 313;
+ }
+ ts.isJSDocSignature = isJSDocSignature;
+ function isJSDocAugmentsTag(node) {
+ return node.kind === 315;
+ }
+ ts.isJSDocAugmentsTag = isJSDocAugmentsTag;
+ function isJSDocAuthorTag(node) {
+ return node.kind === 317;
+ }
+ ts.isJSDocAuthorTag = isJSDocAuthorTag;
+ function isJSDocClassTag(node) {
+ return node.kind === 319;
+ }
+ ts.isJSDocClassTag = isJSDocClassTag;
+ function isJSDocCallbackTag(node) {
+ return node.kind === 324;
+ }
+ ts.isJSDocCallbackTag = isJSDocCallbackTag;
+ function isJSDocPublicTag(node) {
+ return node.kind === 320;
+ }
+ ts.isJSDocPublicTag = isJSDocPublicTag;
+ function isJSDocPrivateTag(node) {
+ return node.kind === 321;
+ }
+ ts.isJSDocPrivateTag = isJSDocPrivateTag;
+ function isJSDocProtectedTag(node) {
+ return node.kind === 322;
+ }
+ ts.isJSDocProtectedTag = isJSDocProtectedTag;
+ function isJSDocReadonlyTag(node) {
+ return node.kind === 323;
+ }
+ ts.isJSDocReadonlyTag = isJSDocReadonlyTag;
+ function isJSDocDeprecatedTag(node) {
+ return node.kind === 318;
+ }
+ ts.isJSDocDeprecatedTag = isJSDocDeprecatedTag;
+ function isJSDocEnumTag(node) {
+ return node.kind === 325;
+ }
+ ts.isJSDocEnumTag = isJSDocEnumTag;
+ function isJSDocParameterTag(node) {
+ return node.kind === 326;
+ }
+ ts.isJSDocParameterTag = isJSDocParameterTag;
+ function isJSDocReturnTag(node) {
+ return node.kind === 327;
+ }
+ ts.isJSDocReturnTag = isJSDocReturnTag;
+ function isJSDocThisTag(node) {
+ return node.kind === 328;
+ }
+ ts.isJSDocThisTag = isJSDocThisTag;
+ function isJSDocTypeTag(node) {
+ return node.kind === 329;
+ }
+ ts.isJSDocTypeTag = isJSDocTypeTag;
+ function isJSDocTemplateTag(node) {
+ return node.kind === 330;
+ }
+ ts.isJSDocTemplateTag = isJSDocTemplateTag;
+ function isJSDocTypedefTag(node) {
+ return node.kind === 331;
+ }
+ ts.isJSDocTypedefTag = isJSDocTypedefTag;
+ function isJSDocUnknownTag(node) {
+ return node.kind === 314;
+ }
+ ts.isJSDocUnknownTag = isJSDocUnknownTag;
+ function isJSDocPropertyTag(node) {
+ return node.kind === 333;
+ }
+ ts.isJSDocPropertyTag = isJSDocPropertyTag;
+ function isJSDocImplementsTag(node) {
+ return node.kind === 316;
+ }
+ ts.isJSDocImplementsTag = isJSDocImplementsTag;
+ function isSyntaxList(n) {
+ return n.kind === 334;
+ }
+ ts.isSyntaxList = isSyntaxList;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createEmptyExports(factory) {
+ return factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports([]), undefined);
+ }
+ ts.createEmptyExports = createEmptyExports;
+ function createMemberAccessForPropertyName(factory, target, memberName, location) {
+ if (ts.isComputedPropertyName(memberName)) {
+ return ts.setTextRange(factory.createElementAccessExpression(target, memberName.expression), location);
+ }
+ else {
+ var expression = ts.setTextRange(ts.isIdentifierOrPrivateIdentifier(memberName)
+ ? factory.createPropertyAccessExpression(target, memberName)
+ : factory.createElementAccessExpression(target, memberName), memberName);
+ ts.getOrCreateEmitNode(expression).flags |= 64;
+ return expression;
+ }
+ }
+ ts.createMemberAccessForPropertyName = createMemberAccessForPropertyName;
+ function createReactNamespace(reactNamespace, parent) {
+ var react = ts.parseNodeFactory.createIdentifier(reactNamespace || "React");
+ ts.setParent(react, ts.getParseTreeNode(parent));
+ return react;
+ }
+ function createJsxFactoryExpressionFromEntityName(factory, jsxFactory, parent) {
+ if (ts.isQualifiedName(jsxFactory)) {
+ var left = createJsxFactoryExpressionFromEntityName(factory, jsxFactory.left, parent);
+ var right = factory.createIdentifier(ts.idText(jsxFactory.right));
+ right.escapedText = jsxFactory.right.escapedText;
+ return factory.createPropertyAccessExpression(left, right);
+ }
+ else {
+ return createReactNamespace(ts.idText(jsxFactory), parent);
+ }
+ }
+ function createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parent) {
+ return jsxFactoryEntity ?
+ createJsxFactoryExpressionFromEntityName(factory, jsxFactoryEntity, parent) :
+ factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "createElement");
+ }
+ ts.createJsxFactoryExpression = createJsxFactoryExpression;
+ function createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parent) {
+ return jsxFragmentFactoryEntity ?
+ createJsxFactoryExpressionFromEntityName(factory, jsxFragmentFactoryEntity, parent) :
+ factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "Fragment");
+ }
+ function createExpressionForJsxElement(factory, callee, tagName, props, children, location) {
+ var argumentsList = [tagName];
+ if (props) {
+ argumentsList.push(props);
+ }
+ if (children && children.length > 0) {
+ if (!props) {
+ argumentsList.push(factory.createNull());
+ }
+ 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(factory.createCallExpression(callee, undefined, argumentsList), location);
+ }
+ ts.createExpressionForJsxElement = createExpressionForJsxElement;
+ function createExpressionForJsxFragment(factory, jsxFactoryEntity, jsxFragmentFactoryEntity, reactNamespace, children, parentElement, location) {
+ var tagName = createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parentElement);
+ var argumentsList = [tagName, factory.createNull()];
+ if (children && children.length > 0) {
+ if (children.length > 1) {
+ for (var _i = 0, children_4 = children; _i < children_4.length; _i++) {
+ var child = children_4[_i];
+ startOnNewLine(child);
+ argumentsList.push(child);
+ }
+ }
+ else {
+ argumentsList.push(children[0]);
+ }
+ }
+ return ts.setTextRange(factory.createCallExpression(createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location);
+ }
+ ts.createExpressionForJsxFragment = createExpressionForJsxFragment;
+ function createForOfBindingStatement(factory, node, boundValue) {
+ if (ts.isVariableDeclarationList(node)) {
+ var firstDeclaration = ts.first(node.declarations);
+ var updatedDeclaration = factory.updateVariableDeclaration(firstDeclaration, firstDeclaration.name, undefined, undefined, boundValue);
+ return ts.setTextRange(factory.createVariableStatement(undefined, factory.updateVariableDeclarationList(node, [updatedDeclaration])), node);
+ }
+ else {
+ var updatedExpression = ts.setTextRange(factory.createAssignment(node, boundValue), node);
+ return ts.setTextRange(factory.createExpressionStatement(updatedExpression), node);
+ }
+ }
+ ts.createForOfBindingStatement = createForOfBindingStatement;
+ function insertLeadingStatement(factory, dest, source) {
+ if (ts.isBlock(dest)) {
+ return factory.updateBlock(dest, ts.setTextRange(factory.createNodeArray(__spreadArrays([source], dest.statements)), dest.statements));
+ }
+ else {
+ return factory.createBlock(factory.createNodeArray([dest, source]), true);
+ }
+ }
+ ts.insertLeadingStatement = insertLeadingStatement;
+ function createExpressionFromEntityName(factory, node) {
+ if (ts.isQualifiedName(node)) {
+ var left = createExpressionFromEntityName(factory, node.left);
+ var right = ts.setParent(ts.setTextRange(factory.cloneNode(node.right), node.right), node.right.parent);
+ return ts.setTextRange(factory.createPropertyAccessExpression(left, right), node);
+ }
+ else {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(node), node), node.parent);
+ }
+ }
+ ts.createExpressionFromEntityName = createExpressionFromEntityName;
+ function createExpressionForPropertyName(factory, memberName) {
+ if (ts.isIdentifier(memberName)) {
+ return factory.createStringLiteralFromNode(memberName);
+ }
+ else if (ts.isComputedPropertyName(memberName)) {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(memberName.expression), memberName.expression), memberName.expression.parent);
+ }
+ else {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(memberName), memberName), memberName.parent);
+ }
+ }
+ ts.createExpressionForPropertyName = createExpressionForPropertyName;
+ function createExpressionForAccessorDeclaration(factory, properties, property, receiver, multiLine) {
+ var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;
+ if (property === firstAccessor) {
+ return ts.setTextRange(factory.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory, property.name), factory.createPropertyDescriptor({
+ enumerable: factory.createFalse(),
+ configurable: true,
+ get: getAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(getAccessor.modifiers, undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body), getAccessor), getAccessor),
+ set: setAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(setAccessor.modifiers, undefined, undefined, undefined, setAccessor.parameters, undefined, setAccessor.body), setAccessor), setAccessor)
+ }, !multiLine)), firstAccessor);
+ }
+ return undefined;
+ }
+ function createExpressionForPropertyAssignment(factory, property, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, property.name), property.initializer), property), property);
+ }
+ function createExpressionForShorthandPropertyAssignment(factory, property, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, property.name), factory.cloneNode(property.name)), property), property);
+ }
+ function createExpressionForMethodDeclaration(factory, method, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, method.name, method.name), ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression(method.modifiers, method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method);
+ }
+ function createExpressionForObjectLiteralElementLike(factory, 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 167:
+ case 168:
+ return createExpressionForAccessorDeclaration(factory, node.properties, property, receiver, !!node.multiLine);
+ case 288:
+ return createExpressionForPropertyAssignment(factory, property, receiver);
+ case 289:
+ return createExpressionForShorthandPropertyAssignment(factory, property, receiver);
+ case 165:
+ return createExpressionForMethodDeclaration(factory, property, receiver);
+ }
+ }
+ ts.createExpressionForObjectLiteralElementLike = createExpressionForObjectLiteralElementLike;
+ function isInternalName(node) {
+ return (ts.getEmitFlags(node) & 32768) !== 0;
+ }
+ ts.isInternalName = isInternalName;
+ function isLocalName(node) {
+ return (ts.getEmitFlags(node) & 16384) !== 0;
+ }
+ ts.isLocalName = isLocalName;
+ function isExportName(node) {
+ return (ts.getEmitFlags(node) & 8192) !== 0;
+ }
+ ts.isExportName = isExportName;
+ function isUseStrictPrologue(node) {
+ return ts.isStringLiteral(node.expression) && node.expression.text === "use strict";
+ }
+ function findUseStrictPrologue(statements) {
+ for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+ var statement = statements_1[_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 isCommaSequence(node) {
+ return node.kind === 216 && node.operatorToken.kind === 27 ||
+ node.kind === 337;
+ }
+ ts.isCommaSequence = isCommaSequence;
+ function isOuterExpression(node, kinds) {
+ if (kinds === void 0) { kinds = 15; }
+ switch (node.kind) {
+ case 207:
+ return (kinds & 1) !== 0;
+ case 206:
+ case 224:
+ return (kinds & 2) !== 0;
+ case 225:
+ return (kinds & 4) !== 0;
+ case 336:
+ return (kinds & 8) !== 0;
+ }
+ return false;
+ }
+ ts.isOuterExpression = isOuterExpression;
+ function skipOuterExpressions(node, kinds) {
+ if (kinds === void 0) { kinds = 15; }
+ while (isOuterExpression(node, kinds)) {
+ node = node.expression;
+ }
+ return node;
+ }
+ ts.skipOuterExpressions = skipOuterExpressions;
+ function skipAssertions(node) {
+ return skipOuterExpressions(node, 6);
+ }
+ ts.skipAssertions = skipAssertions;
+ 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(nodeFactory, helperFactory, 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_3 = helpers; _i < helpers_3.length; _i++) {
+ var helper = helpers_3[_i];
+ if (!helper.scoped) {
+ var importName = helper.importName;
+ if (importName) {
+ ts.pushIfUnique(helperNames, importName);
+ }
+ }
+ }
+ if (ts.some(helperNames)) {
+ helperNames.sort(ts.compareStringsCaseSensitive);
+ namedBindings = nodeFactory.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name)
+ ? nodeFactory.createImportSpecifier(undefined, nodeFactory.createIdentifier(name))
+ : nodeFactory.createImportSpecifier(nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
+ var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
+ var emitNode = ts.getOrCreateEmitNode(parseNode);
+ emitNode.externalHelpers = true;
+ }
+ }
+ }
+ else {
+ var externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault);
+ if (externalHelpersModuleName) {
+ namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName);
+ }
+ }
+ if (namedBindings) {
+ var externalHelpersImportDeclaration = nodeFactory.createImportDeclaration(undefined, undefined, nodeFactory.createImportClause(false, undefined, namedBindings), nodeFactory.createStringLiteral(ts.externalHelpersModuleNameText));
+ ts.addEmitFlags(externalHelpersImportDeclaration, 67108864);
+ return externalHelpersImportDeclaration;
+ }
+ }
+ }
+ ts.createExternalHelpersImportDeclarationIfNeeded = createExternalHelpersImportDeclarationIfNeeded;
+ function getOrCreateExternalHelpersModuleNameIfNeeded(factory, 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_4 = helpers; _i < helpers_4.length; _i++) {
+ var helper = helpers_4[_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 = factory.createUniqueName(ts.externalHelpersModuleNameText));
+ }
+ }
+ }
+ ts.getOrCreateExternalHelpersModuleNameIfNeeded = getOrCreateExternalHelpersModuleNameIfNeeded;
+ function getLocalNameForExternalImport(factory, node, sourceFile) {
+ var namespaceDeclaration = ts.getNamespaceDeclarationNode(node);
+ if (namespaceDeclaration && !ts.isDefaultImport(node) && !ts.isExportNamespaceAsDefaultDeclaration(node)) {
+ var name = namespaceDeclaration.name;
+ return ts.isGeneratedIdentifier(name) ? name : factory.createIdentifier(ts.getSourceTextOfNodeFromSourceFile(sourceFile, name) || ts.idText(name));
+ }
+ if (node.kind === 261 && node.importClause) {
+ return factory.getGeneratedNameForNode(node);
+ }
+ if (node.kind === 267 && node.moduleSpecifier) {
+ return factory.getGeneratedNameForNode(node);
+ }
+ return undefined;
+ }
+ ts.getLocalNameForExternalImport = getLocalNameForExternalImport;
+ function getExternalModuleNameLiteral(factory, importNode, sourceFile, host, resolver, compilerOptions) {
+ var moduleName = ts.getExternalModuleName(importNode);
+ if (moduleName.kind === 10) {
+ return tryGetModuleNameFromDeclaration(importNode, host, factory, resolver, compilerOptions)
+ || tryRenameExternalModule(factory, moduleName, sourceFile)
+ || factory.cloneNode(moduleName);
+ }
+ return undefined;
+ }
+ ts.getExternalModuleNameLiteral = getExternalModuleNameLiteral;
+ function tryRenameExternalModule(factory, moduleName, sourceFile) {
+ var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
+ return rename && factory.createStringLiteral(rename);
+ }
+ function tryGetModuleNameFromFile(factory, file, host, options) {
+ if (!file) {
+ return undefined;
+ }
+ if (file.moduleName) {
+ return factory.createStringLiteral(file.moduleName);
+ }
+ if (!file.isDeclarationFile && ts.outFile(options)) {
+ return factory.createStringLiteral(ts.getExternalModuleNameFromPath(host, file.fileName));
+ }
+ return undefined;
+ }
+ ts.tryGetModuleNameFromFile = tryGetModuleNameFromFile;
+ function tryGetModuleNameFromDeclaration(declaration, host, factory, resolver, compilerOptions) {
+ return tryGetModuleNameFromFile(factory, 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 288:
+ return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
+ case 289:
+ return bindingElement.name;
+ case 290:
+ 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 160:
+ case 198:
+ return bindingElement.dotDotDotToken;
+ case 220:
+ case 290:
+ 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 198:
+ 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 288:
+ 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 290:
+ 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 target;
+ }
+ }
+ ts.tryGetPropertyNameOfBindingOrAssignmentElement = tryGetPropertyNameOfBindingOrAssignmentElement;
+ function isStringOrNumericLiteral(node) {
+ var kind = node.kind;
+ return kind === 10
+ || kind === 8;
+ }
+ function getElementsOfBindingOrAssignmentPattern(name) {
+ switch (name.kind) {
+ case 196:
+ case 197:
+ case 199:
+ return name.elements;
+ case 200:
+ return name.properties;
+ }
+ }
+ ts.getElementsOfBindingOrAssignmentPattern = getElementsOfBindingOrAssignmentPattern;
+ 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;
+ }
+ }
+ }
+ ts.getJSDocTypeAliasName = getJSDocTypeAliasName;
+ function canHaveModifiers(node) {
+ var kind = node.kind;
+ return kind === 160
+ || kind === 162
+ || kind === 163
+ || kind === 164
+ || kind === 165
+ || kind === 166
+ || kind === 167
+ || kind === 168
+ || kind === 171
+ || kind === 208
+ || kind === 209
+ || kind === 221
+ || kind === 232
+ || kind === 251
+ || kind === 252
+ || kind === 253
+ || kind === 254
+ || kind === 255
+ || kind === 256
+ || kind === 260
+ || kind === 261
+ || kind === 266
+ || kind === 267;
+ }
+ ts.canHaveModifiers = canHaveModifiers;
+ function isExportModifier(node) {
+ return node.kind === 92;
+ }
+ ts.isExportModifier = isExportModifier;
+ function isAsyncModifier(node) {
+ return node.kind === 129;
+ }
+ ts.isAsyncModifier = isAsyncModifier;
+ function isStaticModifier(node) {
+ return node.kind === 123;
+ }
+ ts.isStaticModifier = isStaticModifier;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function setTextRange(range, location) {
+ return location ? ts.setTextRangePosEnd(range, location.pos, location.end) : range;
+ }
+ ts.setTextRange = setTextRange;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var NodeConstructor;
+ var TokenConstructor;
+ var IdentifierConstructor;
+ var PrivateIdentifierConstructor;
+ var SourceFileConstructor;
+ ts.parseBaseNodeFactory = {
+ createBaseSourceFileNode: function (kind) { return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, -1, -1); },
+ createBaseIdentifierNode: function (kind) { return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, -1, -1); },
+ createBasePrivateIdentifierNode: function (kind) { return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1); },
+ createBaseTokenNode: function (kind) { return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, -1, -1); },
+ createBaseNode: function (kind) { return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, -1, -1); },
+ };
+ ts.parseNodeFactory = ts.createNodeFactory(1, ts.parseBaseNodeFactory);
+ 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 <= 156) {
+ return;
+ }
+ switch (node.kind) {
+ case 157:
+ return visitNode(cbNode, node.left) ||
+ visitNode(cbNode, node.right);
+ case 159:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.constraint) ||
+ visitNode(cbNode, node.default) ||
+ visitNode(cbNode, node.expression);
+ case 289:
+ 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 290:
+ return visitNode(cbNode, node.expression);
+ case 160:
+ 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 163:
+ 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 162:
+ 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 288:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.initializer);
+ case 249:
+ 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 198:
+ 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 174:
+ case 175:
+ case 169:
+ case 170:
+ case 171:
+ 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 165:
+ case 164:
+ case 166:
+ case 167:
+ case 168:
+ case 208:
+ case 251:
+ case 209:
+ 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 173:
+ return visitNode(cbNode, node.typeName) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 172:
+ return visitNode(cbNode, node.assertsModifier) ||
+ visitNode(cbNode, node.parameterName) ||
+ visitNode(cbNode, node.type);
+ case 176:
+ return visitNode(cbNode, node.exprName);
+ case 177:
+ return visitNodes(cbNode, cbNodes, node.members);
+ case 178:
+ return visitNode(cbNode, node.elementType);
+ case 179:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 182:
+ case 183:
+ return visitNodes(cbNode, cbNodes, node.types);
+ case 184:
+ return visitNode(cbNode, node.checkType) ||
+ visitNode(cbNode, node.extendsType) ||
+ visitNode(cbNode, node.trueType) ||
+ visitNode(cbNode, node.falseType);
+ case 185:
+ return visitNode(cbNode, node.typeParameter);
+ case 195:
+ return visitNode(cbNode, node.argument) ||
+ visitNode(cbNode, node.qualifier) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 186:
+ case 188:
+ return visitNode(cbNode, node.type);
+ case 189:
+ return visitNode(cbNode, node.objectType) ||
+ visitNode(cbNode, node.indexType);
+ case 190:
+ return visitNode(cbNode, node.readonlyToken) ||
+ visitNode(cbNode, node.typeParameter) ||
+ visitNode(cbNode, node.nameType) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type);
+ case 191:
+ return visitNode(cbNode, node.literal);
+ case 192:
+ return visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type);
+ case 196:
+ case 197:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 199:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 200:
+ return visitNodes(cbNode, cbNodes, node.properties);
+ case 201:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNode(cbNode, node.name);
+ case 202:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNode(cbNode, node.argumentExpression);
+ case 203:
+ case 204:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNodes(cbNode, cbNodes, node.arguments);
+ case 205:
+ return visitNode(cbNode, node.tag) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNode(cbNode, node.template);
+ case 206:
+ return visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.expression);
+ case 207:
+ return visitNode(cbNode, node.expression);
+ case 210:
+ return visitNode(cbNode, node.expression);
+ case 211:
+ return visitNode(cbNode, node.expression);
+ case 212:
+ return visitNode(cbNode, node.expression);
+ case 214:
+ return visitNode(cbNode, node.operand);
+ case 219:
+ return visitNode(cbNode, node.asteriskToken) ||
+ visitNode(cbNode, node.expression);
+ case 213:
+ return visitNode(cbNode, node.expression);
+ case 215:
+ return visitNode(cbNode, node.operand);
+ case 216:
+ return visitNode(cbNode, node.left) ||
+ visitNode(cbNode, node.operatorToken) ||
+ visitNode(cbNode, node.right);
+ case 224:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.type);
+ case 225:
+ return visitNode(cbNode, node.expression);
+ case 226:
+ return visitNode(cbNode, node.name);
+ case 217:
+ return visitNode(cbNode, node.condition) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.whenTrue) ||
+ visitNode(cbNode, node.colonToken) ||
+ visitNode(cbNode, node.whenFalse);
+ case 220:
+ return visitNode(cbNode, node.expression);
+ case 230:
+ case 257:
+ return visitNodes(cbNode, cbNodes, node.statements);
+ case 297:
+ return visitNodes(cbNode, cbNodes, node.statements) ||
+ visitNode(cbNode, node.endOfFileToken);
+ case 232:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.declarationList);
+ case 250:
+ return visitNodes(cbNode, cbNodes, node.declarations);
+ case 233:
+ return visitNode(cbNode, node.expression);
+ case 234:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.thenStatement) ||
+ visitNode(cbNode, node.elseStatement);
+ case 235:
+ return visitNode(cbNode, node.statement) ||
+ visitNode(cbNode, node.expression);
+ case 236:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 237:
+ return visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.condition) ||
+ visitNode(cbNode, node.incrementor) ||
+ visitNode(cbNode, node.statement);
+ case 238:
+ return visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 239:
+ return visitNode(cbNode, node.awaitModifier) ||
+ visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 240:
+ case 241:
+ return visitNode(cbNode, node.label);
+ case 242:
+ return visitNode(cbNode, node.expression);
+ case 243:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 244:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.caseBlock);
+ case 258:
+ return visitNodes(cbNode, cbNodes, node.clauses);
+ case 284:
+ return visitNode(cbNode, node.expression) ||
+ visitNodes(cbNode, cbNodes, node.statements);
+ case 285:
+ return visitNodes(cbNode, cbNodes, node.statements);
+ case 245:
+ return visitNode(cbNode, node.label) ||
+ visitNode(cbNode, node.statement);
+ case 246:
+ return visitNode(cbNode, node.expression);
+ case 247:
+ return visitNode(cbNode, node.tryBlock) ||
+ visitNode(cbNode, node.catchClause) ||
+ visitNode(cbNode, node.finallyBlock);
+ case 287:
+ return visitNode(cbNode, node.variableDeclaration) ||
+ visitNode(cbNode, node.block);
+ case 161:
+ return visitNode(cbNode, node.expression);
+ case 252:
+ case 221:
+ 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 253:
+ 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 254:
+ 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 255:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNodes(cbNode, cbNodes, node.members);
+ case 291:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.initializer);
+ case 256:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.body);
+ case 260:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.moduleReference);
+ case 261:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.importClause) ||
+ visitNode(cbNode, node.moduleSpecifier);
+ case 262:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.namedBindings);
+ case 259:
+ return visitNode(cbNode, node.name);
+ case 263:
+ return visitNode(cbNode, node.name);
+ case 269:
+ return visitNode(cbNode, node.name);
+ case 264:
+ case 268:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 267:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.exportClause) ||
+ visitNode(cbNode, node.moduleSpecifier);
+ case 265:
+ case 270:
+ return visitNode(cbNode, node.propertyName) ||
+ visitNode(cbNode, node.name);
+ case 266:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.expression);
+ case 218:
+ return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
+ case 228:
+ return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal);
+ case 193:
+ return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
+ case 194:
+ return visitNode(cbNode, node.type) || visitNode(cbNode, node.literal);
+ case 158:
+ return visitNode(cbNode, node.expression);
+ case 286:
+ return visitNodes(cbNode, cbNodes, node.types);
+ case 223:
+ return visitNode(cbNode, node.expression) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 272:
+ return visitNode(cbNode, node.expression);
+ case 271:
+ return visitNodes(cbNode, cbNodes, node.decorators);
+ case 337:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 273:
+ return visitNode(cbNode, node.openingElement) ||
+ visitNodes(cbNode, cbNodes, node.children) ||
+ visitNode(cbNode, node.closingElement);
+ case 277:
+ return visitNode(cbNode, node.openingFragment) ||
+ visitNodes(cbNode, cbNodes, node.children) ||
+ visitNode(cbNode, node.closingFragment);
+ case 274:
+ case 275:
+ return visitNode(cbNode, node.tagName) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNode(cbNode, node.attributes);
+ case 281:
+ return visitNodes(cbNode, cbNodes, node.properties);
+ case 280:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.initializer);
+ case 282:
+ return visitNode(cbNode, node.expression);
+ case 283:
+ return visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.expression);
+ case 276:
+ return visitNode(cbNode, node.tagName);
+ case 180:
+ case 181:
+ case 301:
+ case 306:
+ case 305:
+ case 307:
+ case 309:
+ return visitNode(cbNode, node.type);
+ case 308:
+ return visitNodes(cbNode, cbNodes, node.parameters) ||
+ visitNode(cbNode, node.type);
+ case 311:
+ return visitNodes(cbNode, cbNodes, node.tags);
+ case 332:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.name);
+ case 302:
+ return visitNode(cbNode, node.name);
+ case 326:
+ case 333:
+ return visitNode(cbNode, node.tagName) ||
+ (node.isNameFirst
+ ? visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.typeExpression)
+ : visitNode(cbNode, node.typeExpression) ||
+ visitNode(cbNode, node.name));
+ case 317:
+ return visitNode(cbNode, node.tagName);
+ case 316:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.class);
+ case 315:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.class);
+ case 330:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.constraint) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters);
+ case 331:
+ return visitNode(cbNode, node.tagName) ||
+ (node.typeExpression &&
+ node.typeExpression.kind === 301
+ ? visitNode(cbNode, node.typeExpression) ||
+ visitNode(cbNode, node.fullName)
+ : visitNode(cbNode, node.fullName) ||
+ visitNode(cbNode, node.typeExpression));
+ case 324:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.fullName) ||
+ visitNode(cbNode, node.typeExpression);
+ case 327:
+ case 329:
+ case 328:
+ case 325:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.typeExpression);
+ case 313:
+ return ts.forEach(node.typeParameters, cbNode) ||
+ ts.forEach(node.parameters, cbNode) ||
+ visitNode(cbNode, node.type);
+ case 312:
+ return ts.forEach(node.jsDocPropertyTags, cbNode);
+ case 314:
+ case 319:
+ case 320:
+ case 321:
+ case 322:
+ case 323:
+ return visitNode(cbNode, node.tagName);
+ case 336:
+ return visitNode(cbNode, node.expression);
+ }
+ }
+ ts.forEachChild = forEachChild;
+ function forEachChildRecursively(rootNode, cbNode, cbNodes) {
+ var stack = [rootNode];
+ while (stack.length) {
+ var parent = stack.pop();
+ var res = visitAllPossibleChildren(parent, gatherPossibleChildren(parent));
+ if (res) {
+ return res;
+ }
+ }
+ return;
+ function gatherPossibleChildren(node) {
+ var children = [];
+ forEachChild(node, addWorkItem, addWorkItem);
+ return children;
+ function addWorkItem(n) {
+ children.unshift(n);
+ }
+ }
+ function visitAllPossibleChildren(parent, children) {
+ for (var _i = 0, children_5 = children; _i < children_5.length; _i++) {
+ var child = children_5[_i];
+ if (ts.isArray(child)) {
+ if (cbNodes) {
+ var res = cbNodes(child, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ }
+ for (var i = child.length - 1; i >= 0; i--) {
+ var realChild = child[i];
+ var res = cbNode(realChild, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ stack.push(realChild);
+ }
+ }
+ else {
+ stack.push(child);
+ var res = cbNode(child, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ }
+ }
+ }
+ }
+ ts.forEachChildRecursively = forEachChildRecursively;
+ function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
+ if (setParentNodes === void 0) { setParentNodes = false; }
+ var tracingData = ["parse", "createSourceFile", { path: fileName }];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
+ 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");
+ ts.tracing.end.apply(ts.tracing, tracingData);
+ 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;
+ function countNode(node) {
+ nodeCount++;
+ return node;
+ }
+ var baseNodeFactory = {
+ createBaseSourceFileNode: function (kind) { return countNode(new SourceFileConstructor(kind, 0, 0)); },
+ createBaseIdentifierNode: function (kind) { return countNode(new IdentifierConstructor(kind, 0, 0)); },
+ createBasePrivateIdentifierNode: function (kind) { return countNode(new PrivateIdentifierConstructor(kind, 0, 0)); },
+ createBaseTokenNode: function (kind) { return countNode(new TokenConstructor(kind, 0, 0)); },
+ createBaseNode: function (kind) { return countNode(new NodeConstructor(kind, 0, 0)); }
+ };
+ var factory = ts.createNodeFactory(1 | 2 | 8, baseNodeFactory);
+ var fileName;
+ var sourceFlags;
+ var sourceText;
+ var languageVersion;
+ var scriptKind;
+ var languageVariant;
+ var parseDiagnostics;
+ var jsDocDiagnostics;
+ var syntaxCursor;
+ var currentToken;
+ var nodeCount;
+ var identifiers;
+ var privateIdentifiers;
+ var identifierCount;
+ var parsingContext;
+ var notParenthesizedArrow;
+ var contextFlags;
+ var topLevel = true;
+ 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_3 = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes);
+ ts.convertToObjectWorker(result_3, result_3.parseDiagnostics, false, undefined, undefined);
+ result_3.referencedFiles = ts.emptyArray;
+ result_3.typeReferenceDirectives = ts.emptyArray;
+ result_3.libReferenceDirectives = ts.emptyArray;
+ result_3.amdDependencies = ts.emptyArray;
+ result_3.hasNoDefaultLib = false;
+ result_3.pragmas = ts.emptyMap;
+ return result_3;
+ }
+ initializeState(fileName, sourceText, languageVersion, syntaxCursor, scriptKind);
+ var result = parseSourceFileWorker(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; }
+ if (setParentNodes === void 0) { setParentNodes = false; }
+ initializeState(fileName, sourceText, languageVersion, syntaxCursor, 6);
+ sourceFlags = contextFlags;
+ nextToken();
+ var pos = getNodePos();
+ var statements, endOfFileToken;
+ if (token() === 1) {
+ statements = createNodeArray([], pos, pos);
+ endOfFileToken = parseTokenNode();
+ }
+ else {
+ var expression = void 0;
+ switch (token()) {
+ case 22:
+ expression = parseArrayLiteralExpression();
+ break;
+ case 109:
+ case 94:
+ case 103:
+ expression = parseTokenNode();
+ break;
+ case 40:
+ if (lookAhead(function () { return nextToken() === 8 && nextToken() !== 58; })) {
+ expression = parsePrefixUnaryExpression();
+ }
+ else {
+ expression = parseObjectLiteralExpression();
+ }
+ break;
+ case 8:
+ case 10:
+ if (lookAhead(function () { return nextToken() !== 58; })) {
+ expression = parseLiteralNode();
+ break;
+ }
+ default:
+ expression = parseObjectLiteralExpression();
+ break;
+ }
+ var statement = factory.createExpressionStatement(expression);
+ finishNode(statement, pos);
+ statements = createNodeArray([statement], pos);
+ endOfFileToken = parseExpectedToken(1, ts.Diagnostics.Unexpected_token);
+ }
+ var sourceFile = createSourceFile(fileName, 2, 6, false, statements, endOfFileToken, sourceFlags);
+ if (setParentNodes) {
+ fixupParentReferences(sourceFile);
+ }
+ sourceFile.nodeCount = nodeCount;
+ sourceFile.identifierCount = identifierCount;
+ sourceFile.identifiers = identifiers;
+ sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ if (jsDocDiagnostics) {
+ sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
+ }
+ var result = sourceFile;
+ clearState();
+ return result;
+ }
+ Parser.parseJsonText = parseJsonText;
+ function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) {
+ NodeConstructor = ts.objectAllocator.getNodeConstructor();
+ TokenConstructor = ts.objectAllocator.getTokenConstructor();
+ IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor();
+ PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor();
+ SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor();
+ fileName = ts.normalizePath(_fileName);
+ sourceText = _sourceText;
+ languageVersion = _languageVersion;
+ syntaxCursor = _syntaxCursor;
+ scriptKind = _scriptKind;
+ languageVariant = ts.getLanguageVariant(_scriptKind);
+ parseDiagnostics = [];
+ parsingContext = 0;
+ identifiers = new ts.Map();
+ privateIdentifiers = new ts.Map();
+ identifierCount = 0;
+ nodeCount = 0;
+ sourceFlags = 0;
+ topLevel = true;
+ 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(languageVariant);
+ }
+ function clearState() {
+ scanner.clearCommentDirectives();
+ scanner.setText("");
+ scanner.setOnError(undefined);
+ sourceText = undefined;
+ languageVersion = undefined;
+ syntaxCursor = undefined;
+ scriptKind = undefined;
+ languageVariant = undefined;
+ sourceFlags = 0;
+ parseDiagnostics = undefined;
+ jsDocDiagnostics = undefined;
+ parsingContext = 0;
+ identifiers = undefined;
+ notParenthesizedArrow = undefined;
+ topLevel = true;
+ }
+ function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind) {
+ var isDeclarationFile = isDeclarationFileName(fileName);
+ if (isDeclarationFile) {
+ contextFlags |= 8388608;
+ }
+ sourceFlags = contextFlags;
+ nextToken();
+ var statements = parseList(0, parseStatement);
+ ts.Debug.assert(token() === 1);
+ var endOfFileToken = addJSDocComment(parseTokenNode());
+ var sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags);
+ processCommentPragmas(sourceFile, sourceText);
+ processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
+ sourceFile.commentDirectives = scanner.getCommentDirectives();
+ sourceFile.nodeCount = nodeCount;
+ sourceFile.identifierCount = identifierCount;
+ sourceFile.identifiers = identifiers;
+ sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ if (jsDocDiagnostics) {
+ sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
+ }
+ if (setParentNodes) {
+ fixupParentReferences(sourceFile);
+ }
+ return sourceFile;
+ function reportPragmaDiagnostic(pos, end, diagnostic) {
+ parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, pos, end, diagnostic));
+ }
+ }
+ function withJSDoc(node, hasJSDoc) {
+ return hasJSDoc ? addJSDocComment(node) : node;
+ }
+ var hasDeprecatedTag = false;
+ function addJSDocComment(node) {
+ ts.Debug.assert(!node.jsDoc);
+ var jsDoc = ts.mapDefined(ts.getJSDocCommentRanges(node, sourceText), function (comment) { return JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos); });
+ if (jsDoc.length)
+ node.jsDoc = jsDoc;
+ if (hasDeprecatedTag) {
+ hasDeprecatedTag = false;
+ node.flags |= 134217728;
+ }
+ return node;
+ }
+ function reparseTopLevelAwait(sourceFile) {
+ var savedSyntaxCursor = syntaxCursor;
+ var baseSyntaxCursor = IncrementalParser.createSyntaxCursor(sourceFile);
+ syntaxCursor = { currentNode: currentNode };
+ var statements = [];
+ var savedParseDiagnostics = parseDiagnostics;
+ parseDiagnostics = [];
+ var pos = 0;
+ var start = findNextStatementWithAwait(sourceFile.statements, 0);
+ var _loop_3 = function () {
+ var prevStatement = sourceFile.statements[pos];
+ var nextStatement = sourceFile.statements[start];
+ ts.addRange(statements, sourceFile.statements, pos, start);
+ pos = findNextStatementWithoutAwait(sourceFile.statements, start);
+ var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement.pos; });
+ var diagnosticEnd = diagnosticStart >= 0 ? ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= nextStatement.pos; }, diagnosticStart) : -1;
+ if (diagnosticStart >= 0) {
+ ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart, diagnosticEnd >= 0 ? diagnosticEnd : undefined);
+ }
+ speculationHelper(function () {
+ var savedContextFlags = contextFlags;
+ contextFlags |= 32768;
+ scanner.setTextPos(nextStatement.pos);
+ nextToken();
+ while (token() !== 1) {
+ var startPos = scanner.getStartPos();
+ var statement = parseListElement(0, parseStatement);
+ statements.push(statement);
+ if (startPos === scanner.getStartPos()) {
+ nextToken();
+ }
+ if (pos >= 0) {
+ var nonAwaitStatement = sourceFile.statements[pos];
+ if (statement.end === nonAwaitStatement.pos) {
+ break;
+ }
+ if (statement.end > nonAwaitStatement.pos) {
+ pos = findNextStatementWithoutAwait(sourceFile.statements, pos + 1);
+ }
+ }
+ }
+ contextFlags = savedContextFlags;
+ }, 2);
+ start = pos >= 0 ? findNextStatementWithAwait(sourceFile.statements, pos) : -1;
+ };
+ while (start !== -1) {
+ _loop_3();
+ }
+ if (pos >= 0) {
+ var prevStatement_1 = sourceFile.statements[pos];
+ ts.addRange(statements, sourceFile.statements, pos);
+ var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement_1.pos; });
+ if (diagnosticStart >= 0) {
+ ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart);
+ }
+ }
+ syntaxCursor = savedSyntaxCursor;
+ return factory.updateSourceFile(sourceFile, ts.setTextRange(factory.createNodeArray(statements), sourceFile.statements));
+ function containsPossibleTopLevelAwait(node) {
+ return !(node.flags & 32768)
+ && !!(node.transformFlags & 8388608);
+ }
+ function findNextStatementWithAwait(statements, start) {
+ for (var i = start; i < statements.length; i++) {
+ if (containsPossibleTopLevelAwait(statements[i])) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function findNextStatementWithoutAwait(statements, start) {
+ for (var i = start; i < statements.length; i++) {
+ if (!containsPossibleTopLevelAwait(statements[i])) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function currentNode(position) {
+ var node = baseSyntaxCursor.currentNode(position);
+ if (topLevel && node && containsPossibleTopLevelAwait(node)) {
+ node.intersectsChange = true;
+ }
+ return node;
+ }
+ }
+ function fixupParentReferences(rootNode) {
+ ts.setParentRecursive(rootNode, true);
+ }
+ Parser.fixupParentReferences = fixupParentReferences;
+ function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, flags) {
+ var sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
+ ts.setTextRangePosWidth(sourceFile, 0, sourceText.length);
+ setExternalModuleIndicator(sourceFile);
+ if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 8388608) {
+ sourceFile = reparseTopLevelAwait(sourceFile);
+ }
+ sourceFile.text = sourceText;
+ sourceFile.bindDiagnostics = [];
+ sourceFile.bindSuggestionDiagnostics = undefined;
+ sourceFile.languageVersion = languageVersion;
+ sourceFile.fileName = fileName;
+ sourceFile.languageVariant = ts.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.createDetachedDiagnostic(fileName, 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 hasPrecedingJSDocComment() {
+ return scanner.hasPrecedingJSDocComment();
+ }
+ function token() {
+ return currentToken;
+ }
+ function nextTokenWithoutCheck() {
+ return currentToken = scanner.scan();
+ }
+ function nextTokenAnd(func) {
+ nextToken();
+ return func();
+ }
+ 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(isTaggedTemplate) {
+ return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
+ }
+ function reScanTemplateHeadOrNoSubstitutionTemplate() {
+ return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
+ }
+ 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, speculationKind) {
+ var saveToken = currentToken;
+ var saveParseDiagnosticsLength = parseDiagnostics.length;
+ var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+ var saveContextFlags = contextFlags;
+ var result = speculationKind !== 0
+ ? scanner.lookAhead(callback)
+ : scanner.tryScan(callback);
+ ts.Debug.assert(saveContextFlags === contextFlags);
+ if (!result || speculationKind !== 0) {
+ currentToken = saveToken;
+ if (speculationKind !== 2) {
+ parseDiagnostics.length = saveParseDiagnosticsLength;
+ }
+ parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
+ }
+ return result;
+ }
+ function lookAhead(callback) {
+ return speculationHelper(callback, 1);
+ }
+ function tryParse(callback) {
+ return speculationHelper(callback, 0);
+ }
+ function isBindingIdentifier() {
+ if (token() === 78) {
+ return true;
+ }
+ return token() > 115;
+ }
+ function isIdentifier() {
+ if (token() === 78) {
+ return true;
+ }
+ if (token() === 124 && inYieldContext()) {
+ return false;
+ }
+ if (token() === 130 && inAwaitContext()) {
+ return false;
+ }
+ return token() > 115;
+ }
+ 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 pos = getNodePos();
+ var kind = token();
+ nextToken();
+ return finishNode(factory.createToken(kind), pos);
+ }
+ function parseTokenNodeJSDoc() {
+ var pos = getNodePos();
+ var kind = token();
+ nextTokenJSDoc();
+ return finishNode(factory.createToken(kind), pos);
+ }
+ 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 createNodeArray(elements, pos, end, hasTrailingComma) {
+ var array = factory.createNodeArray(elements, hasTrailingComma);
+ ts.setTextRangePosEnd(array, pos, end !== null && end !== void 0 ? end : scanner.getStartPos());
+ return array;
+ }
+ function finishNode(node, pos, end) {
+ ts.setTextRangePosEnd(node, pos, end !== null && end !== void 0 ? end : scanner.getStartPos());
+ 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 pos = getNodePos();
+ var result = kind === 78 ? factory.createIdentifier("", undefined, undefined) :
+ ts.isTemplateLiteralKind(kind) ? factory.createTemplateLiteralLikeNode(kind, "", "", undefined) :
+ kind === 8 ? factory.createNumericLiteral("", undefined) :
+ kind === 10 ? factory.createStringLiteral("", undefined) :
+ kind === 271 ? factory.createMissingDeclaration() :
+ factory.createToken(kind);
+ return finishNode(result, pos);
+ }
+ 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 pos = getNodePos();
+ var originalKeywordKind = token();
+ var text = internIdentifier(scanner.getTokenValue());
+ nextTokenWithoutCheck();
+ return finishNode(factory.createIdentifier(text, undefined, originalKeywordKind), pos);
+ }
+ if (token() === 79) {
+ 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(78, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg);
+ }
+ function parseBindingIdentifier(privateIdentifierDiagnosticMessage) {
+ return createIdentifier(isBindingIdentifier(), undefined, privateIdentifierDiagnosticMessage);
+ }
+ 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() === 79) {
+ return parsePrivateIdentifier();
+ }
+ return parseIdentifierName();
+ }
+ function parsePropertyName() {
+ return parsePropertyNameWorker(true);
+ }
+ function parseComputedPropertyName() {
+ var pos = getNodePos();
+ parseExpected(22);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(23);
+ return finishNode(factory.createComputedPropertyName(expression), pos);
+ }
+ function internPrivateIdentifier(text) {
+ var privateIdentifier = privateIdentifiers.get(text);
+ if (privateIdentifier === undefined) {
+ privateIdentifiers.set(text, privateIdentifier = text);
+ }
+ return privateIdentifier;
+ }
+ function parsePrivateIdentifier() {
+ var pos = getNodePos();
+ var node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenText()));
+ nextToken();
+ return finishNode(node, pos);
+ }
+ function parseContextualModifier(t) {
+ return token() === t && tryParse(nextTokenCanFollowModifier);
+ }
+ function nextTokenIsOnSameLineAndCanFollowModifier() {
+ nextToken();
+ if (scanner.hasPrecedingLineBreak()) {
+ return false;
+ }
+ return canFollowModifier();
+ }
+ function nextTokenCanFollowModifier() {
+ switch (token()) {
+ case 84:
+ return nextToken() === 91;
+ case 92:
+ nextToken();
+ if (token() === 87) {
+ return lookAhead(nextTokenCanFollowDefaultKeyword);
+ }
+ if (token() === 149) {
+ return lookAhead(nextTokenCanFollowExportModifier);
+ }
+ return canFollowExportModifier();
+ case 87:
+ return nextTokenCanFollowDefaultKeyword();
+ case 123:
+ case 134:
+ case 146:
+ nextToken();
+ return canFollowModifier();
+ default:
+ return nextTokenIsOnSameLineAndCanFollowModifier();
+ }
+ }
+ function canFollowExportModifier() {
+ return token() !== 41
+ && token() !== 126
+ && 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() === 83 || token() === 97 ||
+ token() === 117 ||
+ (token() === 125 && lookAhead(nextTokenIsClassKeywordOnSameLine)) ||
+ (token() === 129 && 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() === 81 || token() === 87;
+ 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 isBindingIdentifierOrPrivateIdentifierOrPattern();
+ case 10:
+ return token() === 27 || token() === 25 || isBindingIdentifierOrPrivateIdentifierOrPattern();
+ 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 === 93 || next === 116;
+ }
+ 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() === 116 ||
+ token() === 93) {
+ 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() === 81 || token() === 87;
+ case 7:
+ return token() === 18 || token() === 93 || token() === 116;
+ case 8:
+ return isVariableDeclaratorListTerminator();
+ case 19:
+ return token() === 31 || token() === 20 || token() === 18 || token() === 93 || token() === 116;
+ 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 166:
+ case 171:
+ case 167:
+ case 168:
+ case 163:
+ case 229:
+ return true;
+ case 165:
+ var methodDeclaration = node;
+ var nameIsConstructor = methodDeclaration.name.kind === 78 &&
+ methodDeclaration.name.originalKeywordKind === 132;
+ return !nameIsConstructor;
+ }
+ }
+ return false;
+ }
+ function isReusableSwitchClause(node) {
+ if (node) {
+ switch (node.kind) {
+ case 284:
+ case 285:
+ return true;
+ }
+ }
+ return false;
+ }
+ function isReusableStatement(node) {
+ if (node) {
+ switch (node.kind) {
+ case 251:
+ case 232:
+ case 230:
+ case 234:
+ case 233:
+ case 246:
+ case 242:
+ case 244:
+ case 241:
+ case 240:
+ case 238:
+ case 239:
+ case 237:
+ case 236:
+ case 243:
+ case 231:
+ case 247:
+ case 245:
+ case 235:
+ case 248:
+ case 261:
+ case 260:
+ case 267:
+ case 266:
+ case 256:
+ case 252:
+ case 253:
+ case 255:
+ case 254:
+ return true;
+ }
+ }
+ return false;