compiler.js

var denoMain = (function () {
            'use strict';

            var global$1 = (typeof global !== "undefined" ? global :
                        typeof self !== "undefined" ? self :
                        typeof window !== "undefined" ? window : {});

            // shim for using process in browser
            // based off https://github.com/defunctzombie/node-process/blob/master/browser.js

            function defaultSetTimout() {
                throw new Error('setTimeout has not been defined');
            }
            function defaultClearTimeout () {
                throw new Error('clearTimeout has not been defined');
            }
            var cachedSetTimeout = defaultSetTimout;
            var cachedClearTimeout = defaultClearTimeout;
            if (typeof global$1.setTimeout === 'function') {
                cachedSetTimeout = setTimeout;
            }
            if (typeof global$1.clearTimeout === 'function') {
                cachedClearTimeout = clearTimeout;
            }

            function runTimeout(fun) {
                if (cachedSetTimeout === setTimeout) {
                    //normal enviroments in sane situations
                    return setTimeout(fun, 0);
                }
                // if setTimeout wasn't available but was latter defined
                if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                    cachedSetTimeout = setTimeout;
                    return setTimeout(fun, 0);
                }
                try {
                    // when when somebody has screwed with setTimeout but no I.E. maddness
                    return cachedSetTimeout(fun, 0);
                } catch(e){
                    try {
                        // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
                        return cachedSetTimeout.call(null, fun, 0);
                    } catch(e){
                        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
                        return cachedSetTimeout.call(this, fun, 0);
                    }
                }


            }
            function runClearTimeout(marker) {
                if (cachedClearTimeout === clearTimeout) {
                    //normal enviroments in sane situations
                    return clearTimeout(marker);
                }
                // if clearTimeout wasn't available but was latter defined
                if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
                    cachedClearTimeout = clearTimeout;
                    return clearTimeout(marker);
                }
                try {
                    // when when somebody has screwed with setTimeout but no I.E. maddness
                    return cachedClearTimeout(marker);
                } catch (e){
                    try {
                        // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
                        return cachedClearTimeout.call(null, marker);
                    } catch (e){
                        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
                        // Some versions of I.E. have different rules for clearTimeout vs setTimeout
                        return cachedClearTimeout.call(this, marker);
                    }
                }



            }
            var queue = [];
            var draining = false;
            var currentQueue;
            var queueIndex = -1;

            function cleanUpNextTick() {
                if (!draining || !currentQueue) {
                    return;
                }
                draining = false;
                if (currentQueue.length) {
                    queue = currentQueue.concat(queue);
                } else {
                    queueIndex = -1;
                }
                if (queue.length) {
                    drainQueue();
                }
            }

            function drainQueue() {
                if (draining) {
                    return;
                }
                var timeout = runTimeout(cleanUpNextTick);
                draining = true;

                var len = queue.length;
                while(len) {
                    currentQueue = queue;
                    queue = [];
                    while (++queueIndex < len) {
                        if (currentQueue) {
                            currentQueue[queueIndex].run();
                        }
                    }
                    queueIndex = -1;
                    len = queue.length;
                }
                currentQueue = null;
                draining = false;
                runClearTimeout(timeout);
            }
            function nextTick(fun) {
                var args = new Array(arguments.length - 1);
                if (arguments.length > 1) {
                    for (var i = 1; i < arguments.length; i++) {
                        args[i - 1] = arguments[i];
                    }
                }
                queue.push(new Item(fun, args));
                if (queue.length === 1 && !draining) {
                    runTimeout(drainQueue);
                }
            }
            // v8 likes predictible objects
            function Item(fun, array) {
                this.fun = fun;
                this.array = array;
            }
            Item.prototype.run = function () {
                this.fun.apply(null, this.array);
            };
            var title = 'browser';
            var platform = 'browser';
            var browser = true;
            var env = {};
            var argv = [];
            var version = ''; // empty string to avoid regexp issues
            var versions = {};
            var release = {};
            var config = {};

            function noop() {}

            var on = noop;
            var addListener = noop;
            var once = noop;
            var off = noop;
            var removeListener = noop;
            var removeAllListeners = noop;
            var emit = noop;

            function binding(name) {
                throw new Error('process.binding is not supported');
            }

            function cwd () { return '/' }
            function chdir (dir) {
                throw new Error('process.chdir is not supported');
            }function umask() { return 0; }

            // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
            var performance$1 = global$1.performance || {};
            var performanceNow =
              performance$1.now        ||
              performance$1.mozNow     ||
              performance$1.msNow      ||
              performance$1.oNow       ||
              performance$1.webkitNow  ||
              function(){ return (new Date()).getTime() };

            // generate timestamp or delta
            // see http://nodejs.org/api/process.html#process_process_hrtime
            function hrtime(previousTimestamp){
              var clocktime = performanceNow.call(performance$1)*1e-3;
              var seconds = Math.floor(clocktime);
              var nanoseconds = Math.floor((clocktime%1)*1e9);
              if (previousTimestamp) {
                seconds = seconds - previousTimestamp[0];
                nanoseconds = nanoseconds - previousTimestamp[1];
                if (nanoseconds<0) {
                  seconds--;
                  nanoseconds += 1e9;
                }
              }
              return [seconds,nanoseconds]
            }

            var startTime = new Date();
            function uptime() {
              var currentTime = new Date();
              var dif = currentTime - startTime;
              return dif / 1000;
            }

            var process = {
              nextTick: nextTick,
              title: title,
              browser: browser,
              env: env,
              argv: argv,
              version: version,
              versions: versions,
              on: on,
              addListener: addListener,
              once: once,
              off: off,
              removeListener: removeListener,
              removeAllListeners: removeAllListeners,
              emit: emit,
              binding: binding,
              cwd: cwd,
              chdir: chdir,
              umask: umask,
              hrtime: hrtime,
              platform: platform,
              release: release,
              config: config,
              uptime: uptime
            };

            var __filename = '/private/tmp/deno-20190514-62684-1rifxrj/node_modules/typescript/lib/typescript.js';

            var browser$1 = true;

            var __dirname = '/private/tmp/deno-20190514-62684-1rifxrj/node_modules/typescript/lib';

            var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

            function commonjsRequire () {
            	throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
            }

            function unwrapExports (x) {
            	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
            }

            function createCommonjsModule(fn, module) {
            	return module = { exports: {} }, fn(module, module.exports), module.exports;
            }

            // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.

            var mock_builtin = /*#__PURE__*/Object.freeze({
                        default: undefined
            });

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */

            var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');

            /**
             * Encode an integer in the range of 0 to 63 to a single base 64 digit.
             */
            var encode = function (number) {
              if (0 <= number && number < intToCharMap.length) {
                return intToCharMap[number];
              }
              throw new TypeError("Must be between 0 and 63: " + number);
            };

            /**
             * Decode a single base 64 character code digit to an integer. Returns -1 on
             * failure.
             */
            var decode = function (charCode) {
              var bigA = 65;     // 'A'
              var bigZ = 90;     // 'Z'

              var littleA = 97;  // 'a'
              var littleZ = 122; // 'z'

              var zero = 48;     // '0'
              var nine = 57;     // '9'

              var plus = 43;     // '+'
              var slash = 47;    // '/'

              var littleOffset = 26;
              var numberOffset = 52;

              // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
              if (bigA <= charCode && charCode <= bigZ) {
                return (charCode - bigA);
              }

              // 26 - 51: abcdefghijklmnopqrstuvwxyz
              if (littleA <= charCode && charCode <= littleZ) {
                return (charCode - littleA + littleOffset);
              }

              // 52 - 61: 0123456789
              if (zero <= charCode && charCode <= nine) {
                return (charCode - zero + numberOffset);
              }

              // 62: +
              if (charCode == plus) {
                return 62;
              }

              // 63: /
              if (charCode == slash) {
                return 63;
              }

              // Invalid base64 digit.
              return -1;
            };

            var base64 = {
            	encode: encode,
            	decode: decode
            };

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             *
             * Based on the Base 64 VLQ implementation in Closure Compiler:
             * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
             *
             * Copyright 2011 The Closure Compiler Authors. All rights reserved.
             * Redistribution and use in source and binary forms, with or without
             * modification, are permitted provided that the following conditions are
             * met:
             *
             *  * Redistributions of source code must retain the above copyright
             *    notice, this list of conditions and the following disclaimer.
             *  * Redistributions in binary form must reproduce the above
             *    copyright notice, this list of conditions and the following
             *    disclaimer in the documentation and/or other materials provided
             *    with the distribution.
             *  * Neither the name of Google Inc. nor the names of its
             *    contributors may be used to endorse or promote products derived
             *    from this software without specific prior written permission.
             *
             * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
             * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
             * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
             * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
             * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
             * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
             * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
             * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
             * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
             * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
             * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
             */



            // A single base 64 digit can contain 6 bits of data. For the base 64 variable
            // length quantities we use in the source map spec, the first bit is the sign,
            // the next four bits are the actual value, and the 6th bit is the
            // continuation bit. The continuation bit tells us whether there are more
            // digits in this value following this digit.
            //
            //   Continuation
            //   |    Sign
            //   |    |
            //   V    V
            //   101011

            var VLQ_BASE_SHIFT = 5;

            // binary: 100000
            var VLQ_BASE = 1 << VLQ_BASE_SHIFT;

            // binary: 011111
            var VLQ_BASE_MASK = VLQ_BASE - 1;

            // binary: 100000
            var VLQ_CONTINUATION_BIT = VLQ_BASE;

            /**
             * Converts from a two-complement value to a value where the sign bit is
             * placed in the least significant bit.  For example, as decimals:
             *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
             *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
             */
            function toVLQSigned(aValue) {
              return aValue < 0
                ? ((-aValue) << 1) + 1
                : (aValue << 1) + 0;
            }

            /**
             * Converts to a two-complement value from a value where the sign bit is
             * placed in the least significant bit.  For example, as decimals:
             *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
             *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
             */
            function fromVLQSigned(aValue) {
              var isNegative = (aValue & 1) === 1;
              var shifted = aValue >> 1;
              return isNegative
                ? -shifted
                : shifted;
            }

            /**
             * Returns the base 64 VLQ encoded value.
             */
            var encode$1 = function base64VLQ_encode(aValue) {
              var encoded = "";
              var digit;

              var vlq = toVLQSigned(aValue);

              do {
                digit = vlq & VLQ_BASE_MASK;
                vlq >>>= VLQ_BASE_SHIFT;
                if (vlq > 0) {
                  // There are still more digits in this value, so we must make sure the
                  // continuation bit is marked.
                  digit |= VLQ_CONTINUATION_BIT;
                }
                encoded += base64.encode(digit);
              } while (vlq > 0);

              return encoded;
            };

            /**
             * Decodes the next base 64 VLQ value from the given string and returns the
             * value and the rest of the string via the out parameter.
             */
            var decode$1 = function base64VLQ_decode(aStr, aIndex, aOutParam) {
              var strLen = aStr.length;
              var result = 0;
              var shift = 0;
              var continuation, digit;

              do {
                if (aIndex >= strLen) {
                  throw new Error("Expected more digits in base 64 VLQ value.");
                }

                digit = base64.decode(aStr.charCodeAt(aIndex++));
                if (digit === -1) {
                  throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
                }

                continuation = !!(digit & VLQ_CONTINUATION_BIT);
                digit &= VLQ_BASE_MASK;
                result = result + (digit << shift);
                shift += VLQ_BASE_SHIFT;
              } while (continuation);

              aOutParam.value = fromVLQSigned(result);
              aOutParam.rest = aIndex;
            };

            var base64Vlq = {
            	encode: encode$1,
            	decode: decode$1
            };

            var util = createCommonjsModule(function (module, exports) {
            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */

            /**
             * This is a helper function for getting values from parameter/options
             * objects.
             *
             * @param args The object we are extracting values from
             * @param name The name of the property we are getting.
             * @param defaultValue An optional value to return if the property is missing
             * from the object. If this is not specified and the property is missing, an
             * error will be thrown.
             */
            function getArg(aArgs, aName, aDefaultValue) {
              if (aName in aArgs) {
                return aArgs[aName];
              } else if (arguments.length === 3) {
                return aDefaultValue;
              } else {
                throw new Error('"' + aName + '" is a required argument.');
              }
            }
            exports.getArg = getArg;

            var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
            var dataUrlRegexp = /^data:.+\,.+$/;

            function urlParse(aUrl) {
              var match = aUrl.match(urlRegexp);
              if (!match) {
                return null;
              }
              return {
                scheme: match[1],
                auth: match[2],
                host: match[3],
                port: match[4],
                path: match[5]
              };
            }
            exports.urlParse = urlParse;

            function urlGenerate(aParsedUrl) {
              var url = '';
              if (aParsedUrl.scheme) {
                url += aParsedUrl.scheme + ':';
              }
              url += '//';
              if (aParsedUrl.auth) {
                url += aParsedUrl.auth + '@';
              }
              if (aParsedUrl.host) {
                url += aParsedUrl.host;
              }
              if (aParsedUrl.port) {
                url += ":" + aParsedUrl.port;
              }
              if (aParsedUrl.path) {
                url += aParsedUrl.path;
              }
              return url;
            }
            exports.urlGenerate = urlGenerate;

            /**
             * Normalizes a path, or the path portion of a URL:
             *
             * - Replaces consecutive slashes with one slash.
             * - Removes unnecessary '.' parts.
             * - Removes unnecessary '<dir>/..' parts.
             *
             * Based on code in the Node.js 'path' core module.
             *
             * @param aPath The path or url to normalize.
             */
            function normalize(aPath) {
              var path = aPath;
              var url = urlParse(aPath);
              if (url) {
                if (!url.path) {
                  return aPath;
                }
                path = url.path;
              }
              var isAbsolute = exports.isAbsolute(path);

              var parts = path.split(/\/+/);
              for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
                part = parts[i];
                if (part === '.') {
                  parts.splice(i, 1);
                } else if (part === '..') {
                  up++;
                } else if (up > 0) {
                  if (part === '') {
                    // The first part is blank if the path is absolute. Trying to go
                    // above the root is a no-op. Therefore we can remove all '..' parts
                    // directly after the root.
                    parts.splice(i + 1, up);
                    up = 0;
                  } else {
                    parts.splice(i, 2);
                    up--;
                  }
                }
              }
              path = parts.join('/');

              if (path === '') {
                path = isAbsolute ? '/' : '.';
              }

              if (url) {
                url.path = path;
                return urlGenerate(url);
              }
              return path;
            }
            exports.normalize = normalize;

            /**
             * Joins two paths/URLs.
             *
             * @param aRoot The root path or URL.
             * @param aPath The path or URL to be joined with the root.
             *
             * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
             *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
             *   first.
             * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
             *   is updated with the result and aRoot is returned. Otherwise the result
             *   is returned.
             *   - If aPath is absolute, the result is aPath.
             *   - Otherwise the two paths are joined with a slash.
             * - Joining for example 'http://' and 'www.example.com' is also supported.
             */
            function join(aRoot, aPath) {
              if (aRoot === "") {
                aRoot = ".";
              }
              if (aPath === "") {
                aPath = ".";
              }
              var aPathUrl = urlParse(aPath);
              var aRootUrl = urlParse(aRoot);
              if (aRootUrl) {
                aRoot = aRootUrl.path || '/';
              }

              // `join(foo, '//www.example.org')`
              if (aPathUrl && !aPathUrl.scheme) {
                if (aRootUrl) {
                  aPathUrl.scheme = aRootUrl.scheme;
                }
                return urlGenerate(aPathUrl);
              }

              if (aPathUrl || aPath.match(dataUrlRegexp)) {
                return aPath;
              }

              // `join('http://', 'www.example.com')`
              if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
                aRootUrl.host = aPath;
                return urlGenerate(aRootUrl);
              }

              var joined = aPath.charAt(0) === '/'
                ? aPath
                : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);

              if (aRootUrl) {
                aRootUrl.path = joined;
                return urlGenerate(aRootUrl);
              }
              return joined;
            }
            exports.join = join;

            exports.isAbsolute = function (aPath) {
              return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
            };

            /**
             * Make a path relative to a URL or another path.
             *
             * @param aRoot The root path or URL.
             * @param aPath The path or URL to be made relative to aRoot.
             */
            function relative(aRoot, aPath) {
              if (aRoot === "") {
                aRoot = ".";
              }

              aRoot = aRoot.replace(/\/$/, '');

              // It is possible for the path to be above the root. In this case, simply
              // checking whether the root is a prefix of the path won't work. Instead, we
              // need to remove components from the root one by one, until either we find
              // a prefix that fits, or we run out of components to remove.
              var level = 0;
              while (aPath.indexOf(aRoot + '/') !== 0) {
                var index = aRoot.lastIndexOf("/");
                if (index < 0) {
                  return aPath;
                }

                // If the only part of the root that is left is the scheme (i.e. http://,
                // file:///, etc.), one or more slashes (/), or simply nothing at all, we
                // have exhausted all components, so the path is not relative to the root.
                aRoot = aRoot.slice(0, index);
                if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
                  return aPath;
                }

                ++level;
              }

              // Make sure we add a "../" for each component we removed from the root.
              return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
            }
            exports.relative = relative;

            var supportsNullProto = (function () {
              var obj = Object.create(null);
              return !('__proto__' in obj);
            }());

            function identity (s) {
              return s;
            }

            /**
             * Because behavior goes wacky when you set `__proto__` on objects, we
             * have to prefix all the strings in our set with an arbitrary character.
             *
             * See https://github.com/mozilla/source-map/pull/31 and
             * https://github.com/mozilla/source-map/issues/30
             *
             * @param String aStr
             */
            function toSetString(aStr) {
              if (isProtoString(aStr)) {
                return '$' + aStr;
              }

              return aStr;
            }
            exports.toSetString = supportsNullProto ? identity : toSetString;

            function fromSetString(aStr) {
              if (isProtoString(aStr)) {
                return aStr.slice(1);
              }

              return aStr;
            }
            exports.fromSetString = supportsNullProto ? identity : fromSetString;

            function isProtoString(s) {
              if (!s) {
                return false;
              }

              var length = s.length;

              if (length < 9 /* "__proto__".length */) {
                return false;
              }

              if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
                  s.charCodeAt(length - 2) !== 95  /* '_' */ ||
                  s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
                  s.charCodeAt(length - 4) !== 116 /* 't' */ ||
                  s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
                  s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
                  s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
                  s.charCodeAt(length - 8) !== 95  /* '_' */ ||
                  s.charCodeAt(length - 9) !== 95  /* '_' */) {
                return false;
              }

              for (var i = length - 10; i >= 0; i--) {
                if (s.charCodeAt(i) !== 36 /* '$' */) {
                  return false;
                }
              }

              return true;
            }

            /**
             * Comparator between two mappings where the original positions are compared.
             *
             * Optionally pass in `true` as `onlyCompareGenerated` to consider two
             * mappings with the same original source/line/column, but different generated
             * line and column the same. Useful when searching for a mapping with a
             * stubbed out mapping.
             */
            function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
              var cmp = strcmp(mappingA.source, mappingB.source);
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalLine - mappingB.originalLine;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalColumn - mappingB.originalColumn;
              if (cmp !== 0 || onlyCompareOriginal) {
                return cmp;
              }

              cmp = mappingA.generatedColumn - mappingB.generatedColumn;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.generatedLine - mappingB.generatedLine;
              if (cmp !== 0) {
                return cmp;
              }

              return strcmp(mappingA.name, mappingB.name);
            }
            exports.compareByOriginalPositions = compareByOriginalPositions;

            /**
             * Comparator between two mappings with deflated source and name indices where
             * the generated positions are compared.
             *
             * Optionally pass in `true` as `onlyCompareGenerated` to consider two
             * mappings with the same generated line and column, but different
             * source/name/original line and column the same. Useful when searching for a
             * mapping with a stubbed out mapping.
             */
            function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
              var cmp = mappingA.generatedLine - mappingB.generatedLine;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.generatedColumn - mappingB.generatedColumn;
              if (cmp !== 0 || onlyCompareGenerated) {
                return cmp;
              }

              cmp = strcmp(mappingA.source, mappingB.source);
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalLine - mappingB.originalLine;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalColumn - mappingB.originalColumn;
              if (cmp !== 0) {
                return cmp;
              }

              return strcmp(mappingA.name, mappingB.name);
            }
            exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;

            function strcmp(aStr1, aStr2) {
              if (aStr1 === aStr2) {
                return 0;
              }

              if (aStr1 === null) {
                return 1; // aStr2 !== null
              }

              if (aStr2 === null) {
                return -1; // aStr1 !== null
              }

              if (aStr1 > aStr2) {
                return 1;
              }

              return -1;
            }

            /**
             * Comparator between two mappings with inflated source and name strings where
             * the generated positions are compared.
             */
            function compareByGeneratedPositionsInflated(mappingA, mappingB) {
              var cmp = mappingA.generatedLine - mappingB.generatedLine;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.generatedColumn - mappingB.generatedColumn;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = strcmp(mappingA.source, mappingB.source);
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalLine - mappingB.originalLine;
              if (cmp !== 0) {
                return cmp;
              }

              cmp = mappingA.originalColumn - mappingB.originalColumn;
              if (cmp !== 0) {
                return cmp;
              }

              return strcmp(mappingA.name, mappingB.name);
            }
            exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;

            /**
             * Strip any JSON XSSI avoidance prefix from the string (as documented
             * in the source maps specification), and then parse the string as
             * JSON.
             */
            function parseSourceMapInput(str) {
              return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
            }
            exports.parseSourceMapInput = parseSourceMapInput;

            /**
             * Compute the URL of a source given the the source root, the source's
             * URL, and the source map's URL.
             */
            function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
              sourceURL = sourceURL || '';

              if (sourceRoot) {
                // This follows what Chrome does.
                if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
                  sourceRoot += '/';
                }
                // The spec says:
                //   Line 4: An optional source root, useful for relocating source
                //   files on a server or removing repeated values in the
                //   “sources” entry.  This value is prepended to the individual
                //   entries in the “source” field.
                sourceURL = sourceRoot + sourceURL;
              }

              // Historically, SourceMapConsumer did not take the sourceMapURL as
              // a parameter.  This mode is still somewhat supported, which is why
              // this code block is conditional.  However, it's preferable to pass
              // the source map URL to SourceMapConsumer, so that this function
              // can implement the source URL resolution algorithm as outlined in
              // the spec.  This block is basically the equivalent of:
              //    new URL(sourceURL, sourceMapURL).toString()
              // ... except it avoids using URL, which wasn't available in the
              // older releases of node still supported by this library.
              //
              // The spec says:
              //   If the sources are not absolute URLs after prepending of the
              //   “sourceRoot”, the sources are resolved relative to the
              //   SourceMap (like resolving script src in a html document).
              if (sourceMapURL) {
                var parsed = urlParse(sourceMapURL);
                if (!parsed) {
                  throw new Error("sourceMapURL could not be parsed");
                }
                if (parsed.path) {
                  // Strip the last path component, but keep the "/".
                  var index = parsed.path.lastIndexOf('/');
                  if (index >= 0) {
                    parsed.path = parsed.path.substring(0, index + 1);
                  }
                }
                sourceURL = join(urlGenerate(parsed), sourceURL);
              }

              return normalize(sourceURL);
            }
            exports.computeSourceURL = computeSourceURL;
            });
            var util_1 = util.getArg;
            var util_2 = util.urlParse;
            var util_3 = util.urlGenerate;
            var util_4 = util.normalize;
            var util_5 = util.join;
            var util_6 = util.isAbsolute;
            var util_7 = util.relative;
            var util_8 = util.toSetString;
            var util_9 = util.fromSetString;
            var util_10 = util.compareByOriginalPositions;
            var util_11 = util.compareByGeneratedPositionsDeflated;
            var util_12 = util.compareByGeneratedPositionsInflated;
            var util_13 = util.parseSourceMapInput;
            var util_14 = util.computeSourceURL;

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */


            var has = Object.prototype.hasOwnProperty;
            var hasNativeMap = typeof Map !== "undefined";

            /**
             * A data structure which is a combination of an array and a set. Adding a new
             * member is O(1), testing for membership is O(1), and finding the index of an
             * element is O(1). Removing elements from the set is not supported. Only
             * strings are supported for membership.
             */
            function ArraySet() {
              this._array = [];
              this._set = hasNativeMap ? new Map() : Object.create(null);
            }

            /**
             * Static method for creating ArraySet instances from an existing array.
             */
            ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
              var set = new ArraySet();
              for (var i = 0, len = aArray.length; i < len; i++) {
                set.add(aArray[i], aAllowDuplicates);
              }
              return set;
            };

            /**
             * Return how many unique items are in this ArraySet. If duplicates have been
             * added, than those do not count towards the size.
             *
             * @returns Number
             */
            ArraySet.prototype.size = function ArraySet_size() {
              return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
            };

            /**
             * Add the given string to this set.
             *
             * @param String aStr
             */
            ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
              var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
              var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
              var idx = this._array.length;
              if (!isDuplicate || aAllowDuplicates) {
                this._array.push(aStr);
              }
              if (!isDuplicate) {
                if (hasNativeMap) {
                  this._set.set(aStr, idx);
                } else {
                  this._set[sStr] = idx;
                }
              }
            };

            /**
             * Is the given string a member of this set?
             *
             * @param String aStr
             */
            ArraySet.prototype.has = function ArraySet_has(aStr) {
              if (hasNativeMap) {
                return this._set.has(aStr);
              } else {
                var sStr = util.toSetString(aStr);
                return has.call(this._set, sStr);
              }
            };

            /**
             * What is the index of the given string in the array?
             *
             * @param String aStr
             */
            ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
              if (hasNativeMap) {
                var idx = this._set.get(aStr);
                if (idx >= 0) {
                    return idx;
                }
              } else {
                var sStr = util.toSetString(aStr);
                if (has.call(this._set, sStr)) {
                  return this._set[sStr];
                }
              }

              throw new Error('"' + aStr + '" is not in the set.');
            };

            /**
             * What is the element at the given index?
             *
             * @param Number aIdx
             */
            ArraySet.prototype.at = function ArraySet_at(aIdx) {
              if (aIdx >= 0 && aIdx < this._array.length) {
                return this._array[aIdx];
              }
              throw new Error('No element indexed by ' + aIdx);
            };

            /**
             * Returns the array representation of this set (which has the proper indices
             * indicated by indexOf). Note that this is a copy of the internal array used
             * for storing the members so that no one can mess with internal state.
             */
            ArraySet.prototype.toArray = function ArraySet_toArray() {
              return this._array.slice();
            };

            var ArraySet_1 = ArraySet;

            var arraySet = {
            	ArraySet: ArraySet_1
            };

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2014 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */



            /**
             * Determine whether mappingB is after mappingA with respect to generated
             * position.
             */
            function generatedPositionAfter(mappingA, mappingB) {
              // Optimized for most common case
              var lineA = mappingA.generatedLine;
              var lineB = mappingB.generatedLine;
              var columnA = mappingA.generatedColumn;
              var columnB = mappingB.generatedColumn;
              return lineB > lineA || lineB == lineA && columnB >= columnA ||
                     util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
            }

            /**
             * A data structure to provide a sorted view of accumulated mappings in a
             * performance conscious manner. It trades a neglibable overhead in general
             * case for a large speedup in case of mappings being added in order.
             */
            function MappingList() {
              this._array = [];
              this._sorted = true;
              // Serves as infimum
              this._last = {generatedLine: -1, generatedColumn: 0};
            }

            /**
             * Iterate through internal items. This method takes the same arguments that
             * `Array.prototype.forEach` takes.
             *
             * NOTE: The order of the mappings is NOT guaranteed.
             */
            MappingList.prototype.unsortedForEach =
              function MappingList_forEach(aCallback, aThisArg) {
                this._array.forEach(aCallback, aThisArg);
              };

            /**
             * Add the given source mapping.
             *
             * @param Object aMapping
             */
            MappingList.prototype.add = function MappingList_add(aMapping) {
              if (generatedPositionAfter(this._last, aMapping)) {
                this._last = aMapping;
                this._array.push(aMapping);
              } else {
                this._sorted = false;
                this._array.push(aMapping);
              }
            };

            /**
             * Returns the flat, sorted array of mappings. The mappings are sorted by
             * generated position.
             *
             * WARNING: This method returns internal data without copying, for
             * performance. The return value must NOT be mutated, and should be treated as
             * an immutable borrow. If you want to take ownership, you must make your own
             * copy.
             */
            MappingList.prototype.toArray = function MappingList_toArray() {
              if (!this._sorted) {
                this._array.sort(util.compareByGeneratedPositionsInflated);
                this._sorted = true;
              }
              return this._array;
            };

            var MappingList_1 = MappingList;

            var mappingList = {
            	MappingList: MappingList_1
            };

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */



            var ArraySet$1 = arraySet.ArraySet;
            var MappingList$1 = mappingList.MappingList;

            /**
             * An instance of the SourceMapGenerator represents a source map which is
             * being built incrementally. You may pass an object with the following
             * properties:
             *
             *   - file: The filename of the generated source.
             *   - sourceRoot: A root for all relative URLs in this source map.
             */
            function SourceMapGenerator(aArgs) {
              if (!aArgs) {
                aArgs = {};
              }
              this._file = util.getArg(aArgs, 'file', null);
              this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
              this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
              this._sources = new ArraySet$1();
              this._names = new ArraySet$1();
              this._mappings = new MappingList$1();
              this._sourcesContents = null;
            }

            SourceMapGenerator.prototype._version = 3;

            /**
             * Creates a new SourceMapGenerator based on a SourceMapConsumer
             *
             * @param aSourceMapConsumer The SourceMap.
             */
            SourceMapGenerator.fromSourceMap =
              function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
                var sourceRoot = aSourceMapConsumer.sourceRoot;
                var generator = new SourceMapGenerator({
                  file: aSourceMapConsumer.file,
                  sourceRoot: sourceRoot
                });
                aSourceMapConsumer.eachMapping(function (mapping) {
                  var newMapping = {
                    generated: {
                      line: mapping.generatedLine,
                      column: mapping.generatedColumn
                    }
                  };

                  if (mapping.source != null) {
                    newMapping.source = mapping.source;
                    if (sourceRoot != null) {
                      newMapping.source = util.relative(sourceRoot, newMapping.source);
                    }

                    newMapping.original = {
                      line: mapping.originalLine,
                      column: mapping.originalColumn
                    };

                    if (mapping.name != null) {
                      newMapping.name = mapping.name;
                    }
                  }

                  generator.addMapping(newMapping);
                });
                aSourceMapConsumer.sources.forEach(function (sourceFile) {
                  var sourceRelative = sourceFile;
                  if (sourceRoot !== null) {
                    sourceRelative = util.relative(sourceRoot, sourceFile);
                  }

                  if (!generator._sources.has(sourceRelative)) {
                    generator._sources.add(sourceRelative);
                  }

                  var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                  if (content != null) {
                    generator.setSourceContent(sourceFile, content);
                  }
                });
                return generator;
              };

            /**
             * Add a single mapping from original source line and column to the generated
             * source's line and column for this source map being created. The mapping
             * object should have the following properties:
             *
             *   - generated: An object with the generated line and column positions.
             *   - original: An object with the original line and column positions.
             *   - source: The original source file (relative to the sourceRoot).
             *   - name: An optional original token name for this mapping.
             */
            SourceMapGenerator.prototype.addMapping =
              function SourceMapGenerator_addMapping(aArgs) {
                var generated = util.getArg(aArgs, 'generated');
                var original = util.getArg(aArgs, 'original', null);
                var source = util.getArg(aArgs, 'source', null);
                var name = util.getArg(aArgs, 'name', null);

                if (!this._skipValidation) {
                  this._validateMapping(generated, original, source, name);
                }

                if (source != null) {
                  source = String(source);
                  if (!this._sources.has(source)) {
                    this._sources.add(source);
                  }
                }

                if (name != null) {
                  name = String(name);
                  if (!this._names.has(name)) {
                    this._names.add(name);
                  }
                }

                this._mappings.add({
                  generatedLine: generated.line,
                  generatedColumn: generated.column,
                  originalLine: original != null && original.line,
                  originalColumn: original != null && original.column,
                  source: source,
                  name: name
                });
              };

            /**
             * Set the source content for a source file.
             */
            SourceMapGenerator.prototype.setSourceContent =
              function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
                var source = aSourceFile;
                if (this._sourceRoot != null) {
                  source = util.relative(this._sourceRoot, source);
                }

                if (aSourceContent != null) {
                  // Add the source content to the _sourcesContents map.
                  // Create a new _sourcesContents map if the property is null.
                  if (!this._sourcesContents) {
                    this._sourcesContents = Object.create(null);
                  }
                  this._sourcesContents[util.toSetString(source)] = aSourceContent;
                } else if (this._sourcesContents) {
                  // Remove the source file from the _sourcesContents map.
                  // If the _sourcesContents map is empty, set the property to null.
                  delete this._sourcesContents[util.toSetString(source)];
                  if (Object.keys(this._sourcesContents).length === 0) {
                    this._sourcesContents = null;
                  }
                }
              };

            /**
             * Applies the mappings of a sub-source-map for a specific source file to the
             * source map being generated. Each mapping to the supplied source file is
             * rewritten using the supplied source map. Note: The resolution for the
             * resulting mappings is the minimium of this map and the supplied map.
             *
             * @param aSourceMapConsumer The source map to be applied.
             * @param aSourceFile Optional. The filename of the source file.
             *        If omitted, SourceMapConsumer's file property will be used.
             * @param aSourceMapPath Optional. The dirname of the path to the source map
             *        to be applied. If relative, it is relative to the SourceMapConsumer.
             *        This parameter is needed when the two source maps aren't in the same
             *        directory, and the source map to be applied contains relative source
             *        paths. If so, those relative source paths need to be rewritten
             *        relative to the SourceMapGenerator.
             */
            SourceMapGenerator.prototype.applySourceMap =
              function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
                var sourceFile = aSourceFile;
                // If aSourceFile is omitted, we will use the file property of the SourceMap
                if (aSourceFile == null) {
                  if (aSourceMapConsumer.file == null) {
                    throw new Error(
                      'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
                      'or the source map\'s "file" property. Both were omitted.'
                    );
                  }
                  sourceFile = aSourceMapConsumer.file;
                }
                var sourceRoot = this._sourceRoot;
                // Make "sourceFile" relative if an absolute Url is passed.
                if (sourceRoot != null) {
                  sourceFile = util.relative(sourceRoot, sourceFile);
                }
                // Applying the SourceMap can add and remove items from the sources and
                // the names array.
                var newSources = new ArraySet$1();
                var newNames = new ArraySet$1();

                // Find mappings for the "sourceFile"
                this._mappings.unsortedForEach(function (mapping) {
                  if (mapping.source === sourceFile && mapping.originalLine != null) {
                    // Check if it can be mapped by the source map, then update the mapping.
                    var original = aSourceMapConsumer.originalPositionFor({
                      line: mapping.originalLine,
                      column: mapping.originalColumn
                    });
                    if (original.source != null) {
                      // Copy mapping
                      mapping.source = original.source;
                      if (aSourceMapPath != null) {
                        mapping.source = util.join(aSourceMapPath, mapping.source);
                      }
                      if (sourceRoot != null) {
                        mapping.source = util.relative(sourceRoot, mapping.source);
                      }
                      mapping.originalLine = original.line;
                      mapping.originalColumn = original.column;
                      if (original.name != null) {
                        mapping.name = original.name;
                      }
                    }
                  }

                  var source = mapping.source;
                  if (source != null && !newSources.has(source)) {
                    newSources.add(source);
                  }

                  var name = mapping.name;
                  if (name != null && !newNames.has(name)) {
                    newNames.add(name);
                  }

                }, this);
                this._sources = newSources;
                this._names = newNames;

                // Copy sourcesContents of applied map.
                aSourceMapConsumer.sources.forEach(function (sourceFile) {
                  var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                  if (content != null) {
                    if (aSourceMapPath != null) {
                      sourceFile = util.join(aSourceMapPath, sourceFile);
                    }
                    if (sourceRoot != null) {
                      sourceFile = util.relative(sourceRoot, sourceFile);
                    }
                    this.setSourceContent(sourceFile, content);
                  }
                }, this);
              };

            /**
             * A mapping can have one of the three levels of data:
             *
             *   1. Just the generated position.
             *   2. The Generated position, original position, and original source.
             *   3. Generated and original position, original source, as well as a name
             *      token.
             *
             * To maintain consistency, we validate that any new mapping being added falls
             * in to one of these categories.
             */
            SourceMapGenerator.prototype._validateMapping =
              function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
                                                          aName) {
                // When aOriginal is truthy but has empty values for .line and .column,
                // it is most likely a programmer error. In this case we throw a very
                // specific error message to try to guide them the right way.
                // For example: https://github.com/Polymer/polymer-bundler/pull/519
                if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
                    throw new Error(
                        'original.line and original.column are not numbers -- you probably meant to omit ' +
                        'the original mapping entirely and only map the generated position. If so, pass ' +
                        'null for the original mapping instead of an object with empty or null values.'
                    );
                }

                if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
                    && aGenerated.line > 0 && aGenerated.column >= 0
                    && !aOriginal && !aSource && !aName) {
                  // Case 1.
                  return;
                }
                else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
                         && aOriginal && 'line' in aOriginal && 'column' in aOriginal
                         && aGenerated.line > 0 && aGenerated.column >= 0
                         && aOriginal.line > 0 && aOriginal.column >= 0
                         && aSource) {
                  // Cases 2 and 3.
                  return;
                }
                else {
                  throw new Error('Invalid mapping: ' + JSON.stringify({
                    generated: aGenerated,
                    source: aSource,
                    original: aOriginal,
                    name: aName
                  }));
                }
              };

            /**
             * Serialize the accumulated mappings in to the stream of base 64 VLQs
             * specified by the source map format.
             */
            SourceMapGenerator.prototype._serializeMappings =
              function SourceMapGenerator_serializeMappings() {
                var previousGeneratedColumn = 0;
                var previousGeneratedLine = 1;
                var previousOriginalColumn = 0;
                var previousOriginalLine = 0;
                var previousName = 0;
                var previousSource = 0;
                var result = '';
                var next;
                var mapping;
                var nameIdx;
                var sourceIdx;

                var mappings = this._mappings.toArray();
                for (var i = 0, len = mappings.length; i < len; i++) {
                  mapping = mappings[i];
                  next = '';

                  if (mapping.generatedLine !== previousGeneratedLine) {
                    previousGeneratedColumn = 0;
                    while (mapping.generatedLine !== previousGeneratedLine) {
                      next += ';';
                      previousGeneratedLine++;
                    }
                  }
                  else {
                    if (i > 0) {
                      if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
                        continue;
                      }
                      next += ',';
                    }
                  }

                  next += base64Vlq.encode(mapping.generatedColumn
                                             - previousGeneratedColumn);
                  previousGeneratedColumn = mapping.generatedColumn;

                  if (mapping.source != null) {
                    sourceIdx = this._sources.indexOf(mapping.source);
                    next += base64Vlq.encode(sourceIdx - previousSource);
                    previousSource = sourceIdx;

                    // lines are stored 0-based in SourceMap spec version 3
                    next += base64Vlq.encode(mapping.originalLine - 1
                                               - previousOriginalLine);
                    previousOriginalLine = mapping.originalLine - 1;

                    next += base64Vlq.encode(mapping.originalColumn
                                               - previousOriginalColumn);
                    previousOriginalColumn = mapping.originalColumn;

                    if (mapping.name != null) {
                      nameIdx = this._names.indexOf(mapping.name);
                      next += base64Vlq.encode(nameIdx - previousName);
                      previousName = nameIdx;
                    }
                  }

                  result += next;
                }

                return result;
              };

            SourceMapGenerator.prototype._generateSourcesContent =
              function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
                return aSources.map(function (source) {
                  if (!this._sourcesContents) {
                    return null;
                  }
                  if (aSourceRoot != null) {
                    source = util.relative(aSourceRoot, source);
                  }
                  var key = util.toSetString(source);
                  return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
                    ? this._sourcesContents[key]
                    : null;
                }, this);
              };

            /**
             * Externalize the source map.
             */
            SourceMapGenerator.prototype.toJSON =
              function SourceMapGenerator_toJSON() {
                var map = {
                  version: this._version,
                  sources: this._sources.toArray(),
                  names: this._names.toArray(),
                  mappings: this._serializeMappings()
                };
                if (this._file != null) {
                  map.file = this._file;
                }
                if (this._sourceRoot != null) {
                  map.sourceRoot = this._sourceRoot;
                }
                if (this._sourcesContents) {
                  map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
                }

                return map;
              };

            /**
             * Render the source map being generated to a string.
             */
            SourceMapGenerator.prototype.toString =
              function SourceMapGenerator_toString() {
                return JSON.stringify(this.toJSON());
              };

            var SourceMapGenerator_1 = SourceMapGenerator;

            var sourceMapGenerator = {
            	SourceMapGenerator: SourceMapGenerator_1
            };

            var binarySearch = createCommonjsModule(function (module, exports) {
            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */

            exports.GREATEST_LOWER_BOUND = 1;
            exports.LEAST_UPPER_BOUND = 2;

            /**
             * Recursive implementation of binary search.
             *
             * @param aLow Indices here and lower do not contain the needle.
             * @param aHigh Indices here and higher do not contain the needle.
             * @param aNeedle The element being searched for.
             * @param aHaystack The non-empty array being searched.
             * @param aCompare Function which takes two elements and returns -1, 0, or 1.
             * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
             *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
             *     closest element that is smaller than or greater than the one we are
             *     searching for, respectively, if the exact element cannot be found.
             */
            function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
              // This function terminates when one of the following is true:
              //
              //   1. We find the exact element we are looking for.
              //
              //   2. We did not find the exact element, but we can return the index of
              //      the next-closest element.
              //
              //   3. We did not find the exact element, and there is no next-closest
              //      element than the one we are searching for, so we return -1.
              var mid = Math.floor((aHigh - aLow) / 2) + aLow;
              var cmp = aCompare(aNeedle, aHaystack[mid], true);
              if (cmp === 0) {
                // Found the element we are looking for.
                return mid;
              }
              else if (cmp > 0) {
                // Our needle is greater than aHaystack[mid].
                if (aHigh - mid > 1) {
                  // The element is in the upper half.
                  return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
                }

                // The exact needle element was not found in this haystack. Determine if
                // we are in termination case (3) or (2) and return the appropriate thing.
                if (aBias == exports.LEAST_UPPER_BOUND) {
                  return aHigh < aHaystack.length ? aHigh : -1;
                } else {
                  return mid;
                }
              }
              else {
                // Our needle is less than aHaystack[mid].
                if (mid - aLow > 1) {
                  // The element is in the lower half.
                  return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
                }

                // we are in termination case (3) or (2) and return the appropriate thing.
                if (aBias == exports.LEAST_UPPER_BOUND) {
                  return mid;
                } else {
                  return aLow < 0 ? -1 : aLow;
                }
              }
            }

            /**
             * This is an implementation of binary search which will always try and return
             * the index of the closest element if there is no exact hit. This is because
             * mappings between original and generated line/col pairs are single points,
             * and there is an implicit region between each of them, so a miss just means
             * that you aren't on the very start of a region.
             *
             * @param aNeedle The element you are looking for.
             * @param aHaystack The array that is being searched.
             * @param aCompare A function which takes the needle and an element in the
             *     array and returns -1, 0, or 1 depending on whether the needle is less
             *     than, equal to, or greater than the element, respectively.
             * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
             *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
             *     closest element that is smaller than or greater than the one we are
             *     searching for, respectively, if the exact element cannot be found.
             *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
             */
            exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
              if (aHaystack.length === 0) {
                return -1;
              }

              var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
                                          aCompare, aBias || exports.GREATEST_LOWER_BOUND);
              if (index < 0) {
                return -1;
              }

              // We have found either the exact element, or the next-closest element than
              // the one we are searching for. However, there may be more than one such
              // element. Make sure we always return the smallest of these.
              while (index - 1 >= 0) {
                if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
                  break;
                }
                --index;
              }

              return index;
            };
            });
            var binarySearch_1 = binarySearch.GREATEST_LOWER_BOUND;
            var binarySearch_2 = binarySearch.LEAST_UPPER_BOUND;
            var binarySearch_3 = binarySearch.search;

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */

            // It turns out that some (most?) JavaScript engines don't self-host
            // `Array.prototype.sort`. This makes sense because C++ will likely remain
            // faster than JS when doing raw CPU-intensive sorting. However, when using a
            // custom comparator function, calling back and forth between the VM's C++ and
            // JIT'd JS is rather slow *and* loses JIT type information, resulting in
            // worse generated code for the comparator function than would be optimal. In
            // fact, when sorting with a comparator, these costs outweigh the benefits of
            // sorting in C++. By using our own JS-implemented Quick Sort (below), we get
            // a ~3500ms mean speed-up in `bench/bench.html`.

            /**
             * Swap the elements indexed by `x` and `y` in the array `ary`.
             *
             * @param {Array} ary
             *        The array.
             * @param {Number} x
             *        The index of the first item.
             * @param {Number} y
             *        The index of the second item.
             */
            function swap(ary, x, y) {
              var temp = ary[x];
              ary[x] = ary[y];
              ary[y] = temp;
            }

            /**
             * Returns a random integer within the range `low .. high` inclusive.
             *
             * @param {Number} low
             *        The lower bound on the range.
             * @param {Number} high
             *        The upper bound on the range.
             */
            function randomIntInRange(low, high) {
              return Math.round(low + (Math.random() * (high - low)));
            }

            /**
             * The Quick Sort algorithm.
             *
             * @param {Array} ary
             *        An array to sort.
             * @param {function} comparator
             *        Function to use to compare two items.
             * @param {Number} p
             *        Start index of the array
             * @param {Number} r
             *        End index of the array
             */
            function doQuickSort(ary, comparator, p, r) {
              // If our lower bound is less than our upper bound, we (1) partition the
              // array into two pieces and (2) recurse on each half. If it is not, this is
              // the empty array and our base case.

              if (p < r) {
                // (1) Partitioning.
                //
                // The partitioning chooses a pivot between `p` and `r` and moves all
                // elements that are less than or equal to the pivot to the before it, and
                // all the elements that are greater than it after it. The effect is that
                // once partition is done, the pivot is in the exact place it will be when
                // the array is put in sorted order, and it will not need to be moved
                // again. This runs in O(n) time.

                // Always choose a random pivot so that an input array which is reverse
                // sorted does not cause O(n^2) running time.
                var pivotIndex = randomIntInRange(p, r);
                var i = p - 1;

                swap(ary, pivotIndex, r);
                var pivot = ary[r];

                // Immediately after `j` is incremented in this loop, the following hold
                // true:
                //
                //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
                //
                //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
                for (var j = p; j < r; j++) {
                  if (comparator(ary[j], pivot) <= 0) {
                    i += 1;
                    swap(ary, i, j);
                  }
                }

                swap(ary, i + 1, j);
                var q = i + 1;

                // (2) Recurse on each half.

                doQuickSort(ary, comparator, p, q - 1);
                doQuickSort(ary, comparator, q + 1, r);
              }
            }

            /**
             * Sort the given array in-place with the given comparator function.
             *
             * @param {Array} ary
             *        An array to sort.
             * @param {function} comparator
             *        Function to use to compare two items.
             */
            var quickSort_1 = function (ary, comparator) {
              doQuickSort(ary, comparator, 0, ary.length - 1);
            };

            var quickSort = {
            	quickSort: quickSort_1
            };

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */



            var ArraySet$2 = arraySet.ArraySet;

            var quickSort$1 = quickSort.quickSort;

            function SourceMapConsumer(aSourceMap, aSourceMapURL) {
              var sourceMap = aSourceMap;
              if (typeof aSourceMap === 'string') {
                sourceMap = util.parseSourceMapInput(aSourceMap);
              }

              return sourceMap.sections != null
                ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
                : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
            }

            SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
              return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
            };

            /**
             * The version of the source mapping spec that we are consuming.
             */
            SourceMapConsumer.prototype._version = 3;

            // `__generatedMappings` and `__originalMappings` are arrays that hold the
            // parsed mapping coordinates from the source map's "mappings" attribute. They
            // are lazily instantiated, accessed via the `_generatedMappings` and
            // `_originalMappings` getters respectively, and we only parse the mappings
            // and create these arrays once queried for a source location. We jump through
            // these hoops because there can be many thousands of mappings, and parsing
            // them is expensive, so we only want to do it if we must.
            //
            // Each object in the arrays is of the form:
            //
            //     {
            //       generatedLine: The line number in the generated code,
            //       generatedColumn: The column number in the generated code,
            //       source: The path to the original source file that generated this
            //               chunk of code,
            //       originalLine: The line number in the original source that
            //                     corresponds to this chunk of generated code,
            //       originalColumn: The column number in the original source that
            //                       corresponds to this chunk of generated code,
            //       name: The name of the original symbol which generated this chunk of
            //             code.
            //     }
            //
            // All properties except for `generatedLine` and `generatedColumn` can be
            // `null`.
            //
            // `_generatedMappings` is ordered by the generated positions.
            //
            // `_originalMappings` is ordered by the original positions.

            SourceMapConsumer.prototype.__generatedMappings = null;
            Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
              configurable: true,
              enumerable: true,
              get: function () {
                if (!this.__generatedMappings) {
                  this._parseMappings(this._mappings, this.sourceRoot);
                }

                return this.__generatedMappings;
              }
            });

            SourceMapConsumer.prototype.__originalMappings = null;
            Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
              configurable: true,
              enumerable: true,
              get: function () {
                if (!this.__originalMappings) {
                  this._parseMappings(this._mappings, this.sourceRoot);
                }

                return this.__originalMappings;
              }
            });

            SourceMapConsumer.prototype._charIsMappingSeparator =
              function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
                var c = aStr.charAt(index);
                return c === ";" || c === ",";
              };

            /**
             * Parse the mappings in a string in to a data structure which we can easily
             * query (the ordered arrays in the `this.__generatedMappings` and
             * `this.__originalMappings` properties).
             */
            SourceMapConsumer.prototype._parseMappings =
              function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
                throw new Error("Subclasses must implement _parseMappings");
              };

            SourceMapConsumer.GENERATED_ORDER = 1;
            SourceMapConsumer.ORIGINAL_ORDER = 2;

            SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
            SourceMapConsumer.LEAST_UPPER_BOUND = 2;

            /**
             * Iterate over each mapping between an original source/line/column and a
             * generated line/column in this source map.
             *
             * @param Function aCallback
             *        The function that is called with each mapping.
             * @param Object aContext
             *        Optional. If specified, this object will be the value of `this` every
             *        time that `aCallback` is called.
             * @param aOrder
             *        Either `SourceMapConsumer.GENERATED_ORDER` or
             *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
             *        iterate over the mappings sorted by the generated file's line/column
             *        order or the original's source/line/column order, respectively. Defaults to
             *        `SourceMapConsumer.GENERATED_ORDER`.
             */
            SourceMapConsumer.prototype.eachMapping =
              function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
                var context = aContext || null;
                var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

                var mappings;
                switch (order) {
                case SourceMapConsumer.GENERATED_ORDER:
                  mappings = this._generatedMappings;
                  break;
                case SourceMapConsumer.ORIGINAL_ORDER:
                  mappings = this._originalMappings;
                  break;
                default:
                  throw new Error("Unknown order of iteration.");
                }

                var sourceRoot = this.sourceRoot;
                mappings.map(function (mapping) {
                  var source = mapping.source === null ? null : this._sources.at(mapping.source);
                  source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
                  return {
                    source: source,
                    generatedLine: mapping.generatedLine,
                    generatedColumn: mapping.generatedColumn,
                    originalLine: mapping.originalLine,
                    originalColumn: mapping.originalColumn,
                    name: mapping.name === null ? null : this._names.at(mapping.name)
                  };
                }, this).forEach(aCallback, context);
              };

            /**
             * Returns all generated line and column information for the original source,
             * line, and column provided. If no column is provided, returns all mappings
             * corresponding to a either the line we are searching for or the next
             * closest line that has any mappings. Otherwise, returns all mappings
             * corresponding to the given line and either the column we are searching for
             * or the next closest column that has any offsets.
             *
             * The only argument is an object with the following properties:
             *
             *   - source: The filename of the original source.
             *   - line: The line number in the original source.  The line number is 1-based.
             *   - column: Optional. the column number in the original source.
             *    The column number is 0-based.
             *
             * and an array of objects is returned, each with the following properties:
             *
             *   - line: The line number in the generated source, or null.  The
             *    line number is 1-based.
             *   - column: The column number in the generated source, or null.
             *    The column number is 0-based.
             */
            SourceMapConsumer.prototype.allGeneratedPositionsFor =
              function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
                var line = util.getArg(aArgs, 'line');

                // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
                // returns the index of the closest mapping less than the needle. By
                // setting needle.originalColumn to 0, we thus find the last mapping for
                // the given line, provided such a mapping exists.
                var needle = {
                  source: util.getArg(aArgs, 'source'),
                  originalLine: line,
                  originalColumn: util.getArg(aArgs, 'column', 0)
                };

                needle.source = this._findSourceIndex(needle.source);
                if (needle.source < 0) {
                  return [];
                }

                var mappings = [];

                var index = this._findMapping(needle,
                                              this._originalMappings,
                                              "originalLine",
                                              "originalColumn",
                                              util.compareByOriginalPositions,
                                              binarySearch.LEAST_UPPER_BOUND);
                if (index >= 0) {
                  var mapping = this._originalMappings[index];

                  if (aArgs.column === undefined) {
                    var originalLine = mapping.originalLine;

                    // Iterate until either we run out of mappings, or we run into
                    // a mapping for a different line than the one we found. Since
                    // mappings are sorted, this is guaranteed to find all mappings for
                    // the line we found.
                    while (mapping && mapping.originalLine === originalLine) {
                      mappings.push({
                        line: util.getArg(mapping, 'generatedLine', null),
                        column: util.getArg(mapping, 'generatedColumn', null),
                        lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
                      });

                      mapping = this._originalMappings[++index];
                    }
                  } else {
                    var originalColumn = mapping.originalColumn;

                    // Iterate until either we run out of mappings, or we run into
                    // a mapping for a different line than the one we were searching for.
                    // Since mappings are sorted, this is guaranteed to find all mappings for
                    // the line we are searching for.
                    while (mapping &&
                           mapping.originalLine === line &&
                           mapping.originalColumn == originalColumn) {
                      mappings.push({
                        line: util.getArg(mapping, 'generatedLine', null),
                        column: util.getArg(mapping, 'generatedColumn', null),
                        lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
                      });

                      mapping = this._originalMappings[++index];
                    }
                  }
                }

                return mappings;
              };

            var SourceMapConsumer_1 = SourceMapConsumer;

            /**
             * A BasicSourceMapConsumer instance represents a parsed source map which we can
             * query for information about the original file positions by giving it a file
             * position in the generated source.
             *
             * The first parameter is the raw source map (either as a JSON string, or
             * already parsed to an object). According to the spec, source maps have the
             * following attributes:
             *
             *   - version: Which version of the source map spec this map is following.
             *   - sources: An array of URLs to the original source files.
             *   - names: An array of identifiers which can be referrenced by individual mappings.
             *   - sourceRoot: Optional. The URL root from which all sources are relative.
             *   - sourcesContent: Optional. An array of contents of the original source files.
             *   - mappings: A string of base64 VLQs which contain the actual mappings.
             *   - file: Optional. The generated file this source map is associated with.
             *
             * Here is an example source map, taken from the source map spec[0]:
             *
             *     {
             *       version : 3,
             *       file: "out.js",
             *       sourceRoot : "",
             *       sources: ["foo.js", "bar.js"],
             *       names: ["src", "maps", "are", "fun"],
             *       mappings: "AA,AB;;ABCDE;"
             *     }
             *
             * The second parameter, if given, is a string whose value is the URL
             * at which the source map was found.  This URL is used to compute the
             * sources array.
             *
             * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
             */
            function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
              var sourceMap = aSourceMap;
              if (typeof aSourceMap === 'string') {
                sourceMap = util.parseSourceMapInput(aSourceMap);
              }

              var version = util.getArg(sourceMap, 'version');
              var sources = util.getArg(sourceMap, 'sources');
              // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
              // requires the array) to play nice here.
              var names = util.getArg(sourceMap, 'names', []);
              var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
              var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
              var mappings = util.getArg(sourceMap, 'mappings');
              var file = util.getArg(sourceMap, 'file', null);

              // Once again, Sass deviates from the spec and supplies the version as a
              // string rather than a number, so we use loose equality checking here.
              if (version != this._version) {
                throw new Error('Unsupported version: ' + version);
              }

              if (sourceRoot) {
                sourceRoot = util.normalize(sourceRoot);
              }

              sources = sources
                .map(String)
                // Some source maps produce relative source paths like "./foo.js" instead of
                // "foo.js".  Normalize these first so that future comparisons will succeed.
                // See bugzil.la/1090768.
                .map(util.normalize)
                // Always ensure that absolute sources are internally stored relative to
                // the source root, if the source root is absolute. Not doing this would
                // be particularly problematic when the source root is a prefix of the
                // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
                .map(function (source) {
                  return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
                    ? util.relative(sourceRoot, source)
                    : source;
                });

              // Pass `true` below to allow duplicate names and sources. While source maps
              // are intended to be compressed and deduplicated, the TypeScript compiler
              // sometimes generates source maps with duplicates in them. See Github issue
              // #72 and bugzil.la/889492.
              this._names = ArraySet$2.fromArray(names.map(String), true);
              this._sources = ArraySet$2.fromArray(sources, true);

              this._absoluteSources = this._sources.toArray().map(function (s) {
                return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
              });

              this.sourceRoot = sourceRoot;
              this.sourcesContent = sourcesContent;
              this._mappings = mappings;
              this._sourceMapURL = aSourceMapURL;
              this.file = file;
            }

            BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
            BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;

            /**
             * Utility function to find the index of a source.  Returns -1 if not
             * found.
             */
            BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
              var relativeSource = aSource;
              if (this.sourceRoot != null) {
                relativeSource = util.relative(this.sourceRoot, relativeSource);
              }

              if (this._sources.has(relativeSource)) {
                return this._sources.indexOf(relativeSource);
              }

              // Maybe aSource is an absolute URL as returned by |sources|.  In
              // this case we can't simply undo the transform.
              var i;
              for (i = 0; i < this._absoluteSources.length; ++i) {
                if (this._absoluteSources[i] == aSource) {
                  return i;
                }
              }

              return -1;
            };

            /**
             * Create a BasicSourceMapConsumer from a SourceMapGenerator.
             *
             * @param SourceMapGenerator aSourceMap
             *        The source map that will be consumed.
             * @param String aSourceMapURL
             *        The URL at which the source map can be found (optional)
             * @returns BasicSourceMapConsumer
             */
            BasicSourceMapConsumer.fromSourceMap =
              function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
                var smc = Object.create(BasicSourceMapConsumer.prototype);

                var names = smc._names = ArraySet$2.fromArray(aSourceMap._names.toArray(), true);
                var sources = smc._sources = ArraySet$2.fromArray(aSourceMap._sources.toArray(), true);
                smc.sourceRoot = aSourceMap._sourceRoot;
                smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
                                                                        smc.sourceRoot);
                smc.file = aSourceMap._file;
                smc._sourceMapURL = aSourceMapURL;
                smc._absoluteSources = smc._sources.toArray().map(function (s) {
                  return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
                });

                // Because we are modifying the entries (by converting string sources and
                // names to indices into the sources and names ArraySets), we have to make
                // a copy of the entry or else bad things happen. Shared mutable state
                // strikes again! See github issue #191.

                var generatedMappings = aSourceMap._mappings.toArray().slice();
                var destGeneratedMappings = smc.__generatedMappings = [];
                var destOriginalMappings = smc.__originalMappings = [];

                for (var i = 0, length = generatedMappings.length; i < length; i++) {
                  var srcMapping = generatedMappings[i];
                  var destMapping = new Mapping;
                  destMapping.generatedLine = srcMapping.generatedLine;
                  destMapping.generatedColumn = srcMapping.generatedColumn;

                  if (srcMapping.source) {
                    destMapping.source = sources.indexOf(srcMapping.source);
                    destMapping.originalLine = srcMapping.originalLine;
                    destMapping.originalColumn = srcMapping.originalColumn;

                    if (srcMapping.name) {
                      destMapping.name = names.indexOf(srcMapping.name);
                    }

                    destOriginalMappings.push(destMapping);
                  }

                  destGeneratedMappings.push(destMapping);
                }

                quickSort$1(smc.__originalMappings, util.compareByOriginalPositions);

                return smc;
              };

            /**
             * The version of the source mapping spec that we are consuming.
             */
            BasicSourceMapConsumer.prototype._version = 3;

            /**
             * The list of original sources.
             */
            Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
              get: function () {
                return this._absoluteSources.slice();
              }
            });

            /**
             * Provide the JIT with a nice shape / hidden class.
             */
            function Mapping() {
              this.generatedLine = 0;
              this.generatedColumn = 0;
              this.source = null;
              this.originalLine = null;
              this.originalColumn = null;
              this.name = null;
            }

            /**
             * Parse the mappings in a string in to a data structure which we can easily
             * query (the ordered arrays in the `this.__generatedMappings` and
             * `this.__originalMappings` properties).
             */
            BasicSourceMapConsumer.prototype._parseMappings =
              function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
                var generatedLine = 1;
                var previousGeneratedColumn = 0;
                var previousOriginalLine = 0;
                var previousOriginalColumn = 0;
                var previousSource = 0;
                var previousName = 0;
                var length = aStr.length;
                var index = 0;
                var cachedSegments = {};
                var temp = {};
                var originalMappings = [];
                var generatedMappings = [];
                var mapping, str, segment, end, value;

                while (index < length) {
                  if (aStr.charAt(index) === ';') {
                    generatedLine++;
                    index++;
                    previousGeneratedColumn = 0;
                  }
                  else if (aStr.charAt(index) === ',') {
                    index++;
                  }
                  else {
                    mapping = new Mapping();
                    mapping.generatedLine = generatedLine;

                    // Because each offset is encoded relative to the previous one,
                    // many segments often have the same encoding. We can exploit this
                    // fact by caching the parsed variable length fields of each segment,
                    // allowing us to avoid a second parse if we encounter the same
                    // segment again.
                    for (end = index; end < length; end++) {
                      if (this._charIsMappingSeparator(aStr, end)) {
                        break;
                      }
                    }
                    str = aStr.slice(index, end);

                    segment = cachedSegments[str];
                    if (segment) {
                      index += str.length;
                    } else {
                      segment = [];
                      while (index < end) {
                        base64Vlq.decode(aStr, index, temp);
                        value = temp.value;
                        index = temp.rest;
                        segment.push(value);
                      }

                      if (segment.length === 2) {
                        throw new Error('Found a source, but no line and column');
                      }

                      if (segment.length === 3) {
                        throw new Error('Found a source and line, but no column');
                      }

                      cachedSegments[str] = segment;
                    }

                    // Generated column.
                    mapping.generatedColumn = previousGeneratedColumn + segment[0];
                    previousGeneratedColumn = mapping.generatedColumn;

                    if (segment.length > 1) {
                      // Original source.
                      mapping.source = previousSource + segment[1];
                      previousSource += segment[1];

                      // Original line.
                      mapping.originalLine = previousOriginalLine + segment[2];
                      previousOriginalLine = mapping.originalLine;
                      // Lines are stored 0-based
                      mapping.originalLine += 1;

                      // Original column.
                      mapping.originalColumn = previousOriginalColumn + segment[3];
                      previousOriginalColumn = mapping.originalColumn;

                      if (segment.length > 4) {
                        // Original name.
                        mapping.name = previousName + segment[4];
                        previousName += segment[4];
                      }
                    }

                    generatedMappings.push(mapping);
                    if (typeof mapping.originalLine === 'number') {
                      originalMappings.push(mapping);
                    }
                  }
                }

                quickSort$1(generatedMappings, util.compareByGeneratedPositionsDeflated);
                this.__generatedMappings = generatedMappings;

                quickSort$1(originalMappings, util.compareByOriginalPositions);
                this.__originalMappings = originalMappings;
              };

            /**
             * Find the mapping that best matches the hypothetical "needle" mapping that
             * we are searching for in the given "haystack" of mappings.
             */
            BasicSourceMapConsumer.prototype._findMapping =
              function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
                                                     aColumnName, aComparator, aBias) {
                // To return the position we are searching for, we must first find the
                // mapping for the given position and then return the opposite position it
                // points to. Because the mappings are sorted, we can use binary search to
                // find the best mapping.

                if (aNeedle[aLineName] <= 0) {
                  throw new TypeError('Line must be greater than or equal to 1, got '
                                      + aNeedle[aLineName]);
                }
                if (aNeedle[aColumnName] < 0) {
                  throw new TypeError('Column must be greater than or equal to 0, got '
                                      + aNeedle[aColumnName]);
                }

                return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
              };

            /**
             * Compute the last column for each generated mapping. The last column is
             * inclusive.
             */
            BasicSourceMapConsumer.prototype.computeColumnSpans =
              function SourceMapConsumer_computeColumnSpans() {
                for (var index = 0; index < this._generatedMappings.length; ++index) {
                  var mapping = this._generatedMappings[index];

                  // Mappings do not contain a field for the last generated columnt. We
                  // can come up with an optimistic estimate, however, by assuming that
                  // mappings are contiguous (i.e. given two consecutive mappings, the
                  // first mapping ends where the second one starts).
                  if (index + 1 < this._generatedMappings.length) {
                    var nextMapping = this._generatedMappings[index + 1];

                    if (mapping.generatedLine === nextMapping.generatedLine) {
                      mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
                      continue;
                    }
                  }

                  // The last mapping for each line spans the entire line.
                  mapping.lastGeneratedColumn = Infinity;
                }
              };

            /**
             * Returns the original source, line, and column information for the generated
             * source's line and column positions provided. The only argument is an object
             * with the following properties:
             *
             *   - line: The line number in the generated source.  The line number
             *     is 1-based.
             *   - column: The column number in the generated source.  The column
             *     number is 0-based.
             *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
             *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
             *     closest element that is smaller than or greater than the one we are
             *     searching for, respectively, if the exact element cannot be found.
             *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
             *
             * and an object is returned with the following properties:
             *
             *   - source: The original source file, or null.
             *   - line: The line number in the original source, or null.  The
             *     line number is 1-based.
             *   - column: The column number in the original source, or null.  The
             *     column number is 0-based.
             *   - name: The original identifier, or null.
             */
            BasicSourceMapConsumer.prototype.originalPositionFor =
              function SourceMapConsumer_originalPositionFor(aArgs) {
                var needle = {
                  generatedLine: util.getArg(aArgs, 'line'),
                  generatedColumn: util.getArg(aArgs, 'column')
                };

                var index = this._findMapping(
                  needle,
                  this._generatedMappings,
                  "generatedLine",
                  "generatedColumn",
                  util.compareByGeneratedPositionsDeflated,
                  util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
                );

                if (index >= 0) {
                  var mapping = this._generatedMappings[index];

                  if (mapping.generatedLine === needle.generatedLine) {
                    var source = util.getArg(mapping, 'source', null);
                    if (source !== null) {
                      source = this._sources.at(source);
                      source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
                    }
                    var name = util.getArg(mapping, 'name', null);
                    if (name !== null) {
                      name = this._names.at(name);
                    }
                    return {
                      source: source,
                      line: util.getArg(mapping, 'originalLine', null),
                      column: util.getArg(mapping, 'originalColumn', null),
                      name: name
                    };
                  }
                }

                return {
                  source: null,
                  line: null,
                  column: null,
                  name: null
                };
              };

            /**
             * Return true if we have the source content for every source in the source
             * map, false otherwise.
             */
            BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
              function BasicSourceMapConsumer_hasContentsOfAllSources() {
                if (!this.sourcesContent) {
                  return false;
                }
                return this.sourcesContent.length >= this._sources.size() &&
                  !this.sourcesContent.some(function (sc) { return sc == null; });
              };

            /**
             * Returns the original source content. The only argument is the url of the
             * original source file. Returns null if no original source content is
             * available.
             */
            BasicSourceMapConsumer.prototype.sourceContentFor =
              function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
                if (!this.sourcesContent) {
                  return null;
                }

                var index = this._findSourceIndex(aSource);
                if (index >= 0) {
                  return this.sourcesContent[index];
                }

                var relativeSource = aSource;
                if (this.sourceRoot != null) {
                  relativeSource = util.relative(this.sourceRoot, relativeSource);
                }

                var url;
                if (this.sourceRoot != null
                    && (url = util.urlParse(this.sourceRoot))) {
                  // XXX: file:// URIs and absolute paths lead to unexpected behavior for
                  // many users. We can help them out when they expect file:// URIs to
                  // behave like it would if they were running a local HTTP server. See
                  // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
                  var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
                  if (url.scheme == "file"
                      && this._sources.has(fileUriAbsPath)) {
                    return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
                  }

                  if ((!url.path || url.path == "/")
                      && this._sources.has("/" + relativeSource)) {
                    return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
                  }
                }

                // This function is used recursively from
                // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
                // don't want to throw if we can't find the source - we just want to
                // return null, so we provide a flag to exit gracefully.
                if (nullOnMissing) {
                  return null;
                }
                else {
                  throw new Error('"' + relativeSource + '" is not in the SourceMap.');
                }
              };

            /**
             * Returns the generated line and column information for the original source,
             * line, and column positions provided. The only argument is an object with
             * the following properties:
             *
             *   - source: The filename of the original source.
             *   - line: The line number in the original source.  The line number
             *     is 1-based.
             *   - column: The column number in the original source.  The column
             *     number is 0-based.
             *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
             *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
             *     closest element that is smaller than or greater than the one we are
             *     searching for, respectively, if the exact element cannot be found.
             *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
             *
             * and an object is returned with the following properties:
             *
             *   - line: The line number in the generated source, or null.  The
             *     line number is 1-based.
             *   - column: The column number in the generated source, or null.
             *     The column number is 0-based.
             */
            BasicSourceMapConsumer.prototype.generatedPositionFor =
              function SourceMapConsumer_generatedPositionFor(aArgs) {
                var source = util.getArg(aArgs, 'source');
                source = this._findSourceIndex(source);
                if (source < 0) {
                  return {
                    line: null,
                    column: null,
                    lastColumn: null
                  };
                }

                var needle = {
                  source: source,
                  originalLine: util.getArg(aArgs, 'line'),
                  originalColumn: util.getArg(aArgs, 'column')
                };

                var index = this._findMapping(
                  needle,
                  this._originalMappings,
                  "originalLine",
                  "originalColumn",
                  util.compareByOriginalPositions,
                  util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
                );

                if (index >= 0) {
                  var mapping = this._originalMappings[index];

                  if (mapping.source === needle.source) {
                    return {
                      line: util.getArg(mapping, 'generatedLine', null),
                      column: util.getArg(mapping, 'generatedColumn', null),
                      lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
                    };
                  }
                }

                return {
                  line: null,
                  column: null,
                  lastColumn: null
                };
              };

            var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;

            /**
             * An IndexedSourceMapConsumer instance represents a parsed source map which
             * we can query for information. It differs from BasicSourceMapConsumer in
             * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
             * input.
             *
             * The first parameter is a raw source map (either as a JSON string, or already
             * parsed to an object). According to the spec for indexed source maps, they
             * have the following attributes:
             *
             *   - version: Which version of the source map spec this map is following.
             *   - file: Optional. The generated file this source map is associated with.
             *   - sections: A list of section definitions.
             *
             * Each value under the "sections" field has two fields:
             *   - offset: The offset into the original specified at which this section
             *       begins to apply, defined as an object with a "line" and "column"
             *       field.
             *   - map: A source map definition. This source map could also be indexed,
             *       but doesn't have to be.
             *
             * Instead of the "map" field, it's also possible to have a "url" field
             * specifying a URL to retrieve a source map from, but that's currently
             * unsupported.
             *
             * Here's an example source map, taken from the source map spec[0], but
             * modified to omit a section which uses the "url" field.
             *
             *  {
             *    version : 3,
             *    file: "app.js",
             *    sections: [{
             *      offset: {line:100, column:10},
             *      map: {
             *        version : 3,
             *        file: "section.js",
             *        sources: ["foo.js", "bar.js"],
             *        names: ["src", "maps", "are", "fun"],
             *        mappings: "AAAA,E;;ABCDE;"
             *      }
             *    }],
             *  }
             *
             * The second parameter, if given, is a string whose value is the URL
             * at which the source map was found.  This URL is used to compute the
             * sources array.
             *
             * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
             */
            function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
              var sourceMap = aSourceMap;
              if (typeof aSourceMap === 'string') {
                sourceMap = util.parseSourceMapInput(aSourceMap);
              }

              var version = util.getArg(sourceMap, 'version');
              var sections = util.getArg(sourceMap, 'sections');

              if (version != this._version) {
                throw new Error('Unsupported version: ' + version);
              }

              this._sources = new ArraySet$2();
              this._names = new ArraySet$2();

              var lastOffset = {
                line: -1,
                column: 0
              };
              this._sections = sections.map(function (s) {
                if (s.url) {
                  // The url field will require support for asynchronicity.
                  // See https://github.com/mozilla/source-map/issues/16
                  throw new Error('Support for url field in sections not implemented.');
                }
                var offset = util.getArg(s, 'offset');
                var offsetLine = util.getArg(offset, 'line');
                var offsetColumn = util.getArg(offset, 'column');

                if (offsetLine < lastOffset.line ||
                    (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
                  throw new Error('Section offsets must be ordered and non-overlapping.');
                }
                lastOffset = offset;

                return {
                  generatedOffset: {
                    // The offset fields are 0-based, but we use 1-based indices when
                    // encoding/decoding from VLQ.
                    generatedLine: offsetLine + 1,
                    generatedColumn: offsetColumn + 1
                  },
                  consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
                }
              });
            }

            IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
            IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;

            /**
             * The version of the source mapping spec that we are consuming.
             */
            IndexedSourceMapConsumer.prototype._version = 3;

            /**
             * The list of original sources.
             */
            Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
              get: function () {
                var sources = [];
                for (var i = 0; i < this._sections.length; i++) {
                  for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
                    sources.push(this._sections[i].consumer.sources[j]);
                  }
                }
                return sources;
              }
            });

            /**
             * Returns the original source, line, and column information for the generated
             * source's line and column positions provided. The only argument is an object
             * with the following properties:
             *
             *   - line: The line number in the generated source.  The line number
             *     is 1-based.
             *   - column: The column number in the generated source.  The column
             *     number is 0-based.
             *
             * and an object is returned with the following properties:
             *
             *   - source: The original source file, or null.
             *   - line: The line number in the original source, or null.  The
             *     line number is 1-based.
             *   - column: The column number in the original source, or null.  The
             *     column number is 0-based.
             *   - name: The original identifier, or null.
             */
            IndexedSourceMapConsumer.prototype.originalPositionFor =
              function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
                var needle = {
                  generatedLine: util.getArg(aArgs, 'line'),
                  generatedColumn: util.getArg(aArgs, 'column')
                };

                // Find the section containing the generated position we're trying to map
                // to an original position.
                var sectionIndex = binarySearch.search(needle, this._sections,
                  function(needle, section) {
                    var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
                    if (cmp) {
                      return cmp;
                    }

                    return (needle.generatedColumn -
                            section.generatedOffset.generatedColumn);
                  });
                var section = this._sections[sectionIndex];

                if (!section) {
                  return {
                    source: null,
                    line: null,
                    column: null,
                    name: null
                  };
                }

                return section.consumer.originalPositionFor({
                  line: needle.generatedLine -
                    (section.generatedOffset.generatedLine - 1),
                  column: needle.generatedColumn -
                    (section.generatedOffset.generatedLine === needle.generatedLine
                     ? section.generatedOffset.generatedColumn - 1
                     : 0),
                  bias: aArgs.bias
                });
              };

            /**
             * Return true if we have the source content for every source in the source
             * map, false otherwise.
             */
            IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
              function IndexedSourceMapConsumer_hasContentsOfAllSources() {
                return this._sections.every(function (s) {
                  return s.consumer.hasContentsOfAllSources();
                });
              };

            /**
             * Returns the original source content. The only argument is the url of the
             * original source file. Returns null if no original source content is
             * available.
             */
            IndexedSourceMapConsumer.prototype.sourceContentFor =
              function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
                for (var i = 0; i < this._sections.length; i++) {
                  var section = this._sections[i];

                  var content = section.consumer.sourceContentFor(aSource, true);
                  if (content) {
                    return content;
                  }
                }
                if (nullOnMissing) {
                  return null;
                }
                else {
                  throw new Error('"' + aSource + '" is not in the SourceMap.');
                }
              };

            /**
             * Returns the generated line and column information for the original source,
             * line, and column positions provided. The only argument is an object with
             * the following properties:
             *
             *   - source: The filename of the original source.
             *   - line: The line number in the original source.  The line number
             *     is 1-based.
             *   - column: The column number in the original source.  The column
             *     number is 0-based.
             *
             * and an object is returned with the following properties:
             *
             *   - line: The line number in the generated source, or null.  The
             *     line number is 1-based.
             *   - column: The column number in the generated source, or null.
             *     The column number is 0-based.
             */
            IndexedSourceMapConsumer.prototype.generatedPositionFor =
              function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
                for (var i = 0; i < this._sections.length; i++) {
                  var section = this._sections[i];

                  // Only consider this section if the requested source is in the list of
                  // sources of the consumer.
                  if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
                    continue;
                  }
                  var generatedPosition = section.consumer.generatedPositionFor(aArgs);
                  if (generatedPosition) {
                    var ret = {
                      line: generatedPosition.line +
                        (section.generatedOffset.generatedLine - 1),
                      column: generatedPosition.column +
                        (section.generatedOffset.generatedLine === generatedPosition.line
                         ? section.generatedOffset.generatedColumn - 1
                         : 0)
                    };
                    return ret;
                  }
                }

                return {
                  line: null,
                  column: null
                };
              };

            /**
             * Parse the mappings in a string in to a data structure which we can easily
             * query (the ordered arrays in the `this.__generatedMappings` and
             * `this.__originalMappings` properties).
             */
            IndexedSourceMapConsumer.prototype._parseMappings =
              function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
                this.__generatedMappings = [];
                this.__originalMappings = [];
                for (var i = 0; i < this._sections.length; i++) {
                  var section = this._sections[i];
                  var sectionMappings = section.consumer._generatedMappings;
                  for (var j = 0; j < sectionMappings.length; j++) {
                    var mapping = sectionMappings[j];

                    var source = section.consumer._sources.at(mapping.source);
                    source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
                    this._sources.add(source);
                    source = this._sources.indexOf(source);

                    var name = null;
                    if (mapping.name) {
                      name = section.consumer._names.at(mapping.name);
                      this._names.add(name);
                      name = this._names.indexOf(name);
                    }

                    // The mappings coming from the consumer for the section have
                    // generated positions relative to the start of the section, so we
                    // need to offset them to be relative to the start of the concatenated
                    // generated file.
                    var adjustedMapping = {
                      source: source,
                      generatedLine: mapping.generatedLine +
                        (section.generatedOffset.generatedLine - 1),
                      generatedColumn: mapping.generatedColumn +
                        (section.generatedOffset.generatedLine === mapping.generatedLine
                        ? section.generatedOffset.generatedColumn - 1
                        : 0),
                      originalLine: mapping.originalLine,
                      originalColumn: mapping.originalColumn,
                      name: name
                    };

                    this.__generatedMappings.push(adjustedMapping);
                    if (typeof adjustedMapping.originalLine === 'number') {
                      this.__originalMappings.push(adjustedMapping);
                    }
                  }
                }

                quickSort$1(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
                quickSort$1(this.__originalMappings, util.compareByOriginalPositions);
              };

            var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;

            var sourceMapConsumer = {
            	SourceMapConsumer: SourceMapConsumer_1,
            	BasicSourceMapConsumer: BasicSourceMapConsumer_1,
            	IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
            };

            /* -*- Mode: js; js-indent-level: 2; -*- */
            /*
             * Copyright 2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE or:
             * http://opensource.org/licenses/BSD-3-Clause
             */

            var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;


            // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
            // operating systems these days (capturing the result).
            var REGEX_NEWLINE = /(\r?\n)/;

            // Newline character code for charCodeAt() comparisons
            var NEWLINE_CODE = 10;

            // Private symbol for identifying `SourceNode`s when multiple versions of
            // the source-map library are loaded. This MUST NOT CHANGE across
            // versions!
            var isSourceNode = "$$$isSourceNode$$$";

            /**
             * SourceNodes provide a way to abstract over interpolating/concatenating
             * snippets of generated JavaScript source code while maintaining the line and
             * column information associated with the original source code.
             *
             * @param aLine The original line number.
             * @param aColumn The original column number.
             * @param aSource The original source's filename.
             * @param aChunks Optional. An array of strings which are snippets of
             *        generated JS, or other SourceNodes.
             * @param aName The original identifier.
             */
            function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
              this.children = [];
              this.sourceContents = {};
              this.line = aLine == null ? null : aLine;
              this.column = aColumn == null ? null : aColumn;
              this.source = aSource == null ? null : aSource;
              this.name = aName == null ? null : aName;
              this[isSourceNode] = true;
              if (aChunks != null) this.add(aChunks);
            }

            /**
             * Creates a SourceNode from generated code and a SourceMapConsumer.
             *
             * @param aGeneratedCode The generated code
             * @param aSourceMapConsumer The SourceMap for the generated code
             * @param aRelativePath Optional. The path that relative sources in the
             *        SourceMapConsumer should be relative to.
             */
            SourceNode.fromStringWithSourceMap =
              function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
                // The SourceNode we want to fill with the generated code
                // and the SourceMap
                var node = new SourceNode();

                // All even indices of this array are one line of the generated code,
                // while all odd indices are the newlines between two adjacent lines
                // (since `REGEX_NEWLINE` captures its match).
                // Processed fragments are accessed by calling `shiftNextLine`.
                var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
                var remainingLinesIndex = 0;
                var shiftNextLine = function() {
                  var lineContents = getNextLine();
                  // The last line of a file might not have a newline.
                  var newLine = getNextLine() || "";
                  return lineContents + newLine;

                  function getNextLine() {
                    return remainingLinesIndex < remainingLines.length ?
                        remainingLines[remainingLinesIndex++] : undefined;
                  }
                };

                // We need to remember the position of "remainingLines"
                var lastGeneratedLine = 1, lastGeneratedColumn = 0;

                // The generate SourceNodes we need a code range.
                // To extract it current and last mapping is used.
                // Here we store the last mapping.
                var lastMapping = null;

                aSourceMapConsumer.eachMapping(function (mapping) {
                  if (lastMapping !== null) {
                    // We add the code from "lastMapping" to "mapping":
                    // First check if there is a new line in between.
                    if (lastGeneratedLine < mapping.generatedLine) {
                      // Associate first line with "lastMapping"
                      addMappingWithCode(lastMapping, shiftNextLine());
                      lastGeneratedLine++;
                      lastGeneratedColumn = 0;
                      // The remaining code is added without mapping
                    } else {
                      // There is no new line in between.
                      // Associate the code between "lastGeneratedColumn" and
                      // "mapping.generatedColumn" with "lastMapping"
                      var nextLine = remainingLines[remainingLinesIndex] || '';
                      var code = nextLine.substr(0, mapping.generatedColumn -
                                                    lastGeneratedColumn);
                      remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
                                                          lastGeneratedColumn);
                      lastGeneratedColumn = mapping.generatedColumn;
                      addMappingWithCode(lastMapping, code);
                      // No more remaining code, continue
                      lastMapping = mapping;
                      return;
                    }
                  }
                  // We add the generated code until the first mapping
                  // to the SourceNode without any mapping.
                  // Each line is added as separate string.
                  while (lastGeneratedLine < mapping.generatedLine) {
                    node.add(shiftNextLine());
                    lastGeneratedLine++;
                  }
                  if (lastGeneratedColumn < mapping.generatedColumn) {
                    var nextLine = remainingLines[remainingLinesIndex] || '';
                    node.add(nextLine.substr(0, mapping.generatedColumn));
                    remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
                    lastGeneratedColumn = mapping.generatedColumn;
                  }
                  lastMapping = mapping;
                }, this);
                // We have processed all mappings.
                if (remainingLinesIndex < remainingLines.length) {
                  if (lastMapping) {
                    // Associate the remaining code in the current line with "lastMapping"
                    addMappingWithCode(lastMapping, shiftNextLine());
                  }
                  // and add the remaining lines without any mapping
                  node.add(remainingLines.splice(remainingLinesIndex).join(""));
                }

                // Copy sourcesContent into SourceNode
                aSourceMapConsumer.sources.forEach(function (sourceFile) {
                  var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                  if (content != null) {
                    if (aRelativePath != null) {
                      sourceFile = util.join(aRelativePath, sourceFile);
                    }
                    node.setSourceContent(sourceFile, content);
                  }
                });

                return node;

                function addMappingWithCode(mapping, code) {
                  if (mapping === null || mapping.source === undefined) {
                    node.add(code);
                  } else {
                    var source = aRelativePath
                      ? util.join(aRelativePath, mapping.source)
                      : mapping.source;
                    node.add(new SourceNode(mapping.originalLine,
                                            mapping.originalColumn,
                                            source,
                                            code,
                                            mapping.name));
                  }
                }
              };

            /**
             * Add a chunk of generated JS to this source node.
             *
             * @param aChunk A string snippet of generated JS code, another instance of
             *        SourceNode, or an array where each member is one of those things.
             */
            SourceNode.prototype.add = function SourceNode_add(aChunk) {
              if (Array.isArray(aChunk)) {
                aChunk.forEach(function (chunk) {
                  this.add(chunk);
                }, this);
              }
              else if (aChunk[isSourceNode] || typeof aChunk === "string") {
                if (aChunk) {
                  this.children.push(aChunk);
                }
              }
              else {
                throw new TypeError(
                  "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
                );
              }
              return this;
            };

            /**
             * Add a chunk of generated JS to the beginning of this source node.
             *
             * @param aChunk A string snippet of generated JS code, another instance of
             *        SourceNode, or an array where each member is one of those things.
             */
            SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
              if (Array.isArray(aChunk)) {
                for (var i = aChunk.length-1; i >= 0; i--) {
                  this.prepend(aChunk[i]);
                }
              }
              else if (aChunk[isSourceNode] || typeof aChunk === "string") {
                this.children.unshift(aChunk);
              }
              else {
                throw new TypeError(
                  "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
                );
              }
              return this;
            };

            /**
             * Walk over the tree of JS snippets in this node and its children. The
             * walking function is called once for each snippet of JS and is passed that
             * snippet and the its original associated source's line/column location.
             *
             * @param aFn The traversal function.
             */
            SourceNode.prototype.walk = function SourceNode_walk(aFn) {
              var chunk;
              for (var i = 0, len = this.children.length; i < len; i++) {
                chunk = this.children[i];
                if (chunk[isSourceNode]) {
                  chunk.walk(aFn);
                }
                else {
                  if (chunk !== '') {
                    aFn(chunk, { source: this.source,
                                 line: this.line,
                                 column: this.column,
                                 name: this.name });
                  }
                }
              }
            };

            /**
             * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
             * each of `this.children`.
             *
             * @param aSep The separator.
             */
            SourceNode.prototype.join = function SourceNode_join(aSep) {
              var newChildren;
              var i;
              var len = this.children.length;
              if (len > 0) {
                newChildren = [];
                for (i = 0; i < len-1; i++) {
                  newChildren.push(this.children[i]);
                  newChildren.push(aSep);
                }
                newChildren.push(this.children[i]);
                this.children = newChildren;
              }
              return this;
            };

            /**
             * Call String.prototype.replace on the very right-most source snippet. Useful
             * for trimming whitespace from the end of a source node, etc.
             *
             * @param aPattern The pattern to replace.
             * @param aReplacement The thing to replace the pattern with.
             */
            SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
              var lastChild = this.children[this.children.length - 1];
              if (lastChild[isSourceNode]) {
                lastChild.replaceRight(aPattern, aReplacement);
              }
              else if (typeof lastChild === 'string') {
                this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
              }
              else {
                this.children.push(''.replace(aPattern, aReplacement));
              }
              return this;
            };

            /**
             * Set the source content for a source file. This will be added to the SourceMapGenerator
             * in the sourcesContent field.
             *
             * @param aSourceFile The filename of the source file
             * @param aSourceContent The content of the source file
             */
            SourceNode.prototype.setSourceContent =
              function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
                this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
              };

            /**
             * Walk over the tree of SourceNodes. The walking function is called for each
             * source file content and is passed the filename and source content.
             *
             * @param aFn The traversal function.
             */
            SourceNode.prototype.walkSourceContents =
              function SourceNode_walkSourceContents(aFn) {
                for (var i = 0, len = this.children.length; i < len; i++) {
                  if (this.children[i][isSourceNode]) {
                    this.children[i].walkSourceContents(aFn);
                  }
                }

                var sources = Object.keys(this.sourceContents);
                for (var i = 0, len = sources.length; i < len; i++) {
                  aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
                }
              };

            /**
             * Return the string representation of this source node. Walks over the tree
             * and concatenates all the various snippets together to one string.
             */
            SourceNode.prototype.toString = function SourceNode_toString() {
              var str = "";
              this.walk(function (chunk) {
                str += chunk;
              });
              return str;
            };

            /**
             * Returns the string representation of this source node along with a source
             * map.
             */
            SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
              var generated = {
                code: "",
                line: 1,
                column: 0
              };
              var map = new SourceMapGenerator$1(aArgs);
              var sourceMappingActive = false;
              var lastOriginalSource = null;
              var lastOriginalLine = null;
              var lastOriginalColumn = null;
              var lastOriginalName = null;
              this.walk(function (chunk, original) {
                generated.code += chunk;
                if (original.source !== null
                    && original.line !== null
                    && original.column !== null) {
                  if(lastOriginalSource !== original.source
                     || lastOriginalLine !== original.line
                     || lastOriginalColumn !== original.column
                     || lastOriginalName !== original.name) {
                    map.addMapping({
                      source: original.source,
                      original: {
                        line: original.line,
                        column: original.column
                      },
                      generated: {
                        line: generated.line,
                        column: generated.column
                      },
                      name: original.name
                    });
                  }
                  lastOriginalSource = original.source;
                  lastOriginalLine = original.line;
                  lastOriginalColumn = original.column;
                  lastOriginalName = original.name;
                  sourceMappingActive = true;
                } else if (sourceMappingActive) {
                  map.addMapping({
                    generated: {
                      line: generated.line,
                      column: generated.column
                    }
                  });
                  lastOriginalSource = null;
                  sourceMappingActive = false;
                }
                for (var idx = 0, length = chunk.length; idx < length; idx++) {
                  if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
                    generated.line++;
                    generated.column = 0;
                    // Mappings end at eol
                    if (idx + 1 === length) {
                      lastOriginalSource = null;
                      sourceMappingActive = false;
                    } else if (sourceMappingActive) {
                      map.addMapping({
                        source: original.source,
                        original: {
                          line: original.line,
                          column: original.column
                        },
                        generated: {
                          line: generated.line,
                          column: generated.column
                        },
                        name: original.name
                      });
                    }
                  } else {
                    generated.column++;
                  }
                }
              });
              this.walkSourceContents(function (sourceFile, sourceContent) {
                map.setSourceContent(sourceFile, sourceContent);
              });

              return { code: generated.code, map: map };
            };

            var SourceNode_1 = SourceNode;

            var sourceNode = {
            	SourceNode: SourceNode_1
            };

            /*
             * Copyright 2009-2011 Mozilla Foundation and contributors
             * Licensed under the New BSD license. See LICENSE.txt or:
             * http://opensource.org/licenses/BSD-3-Clause
             */
            var SourceMapGenerator$2 = sourceMapGenerator.SourceMapGenerator;
            var SourceMapConsumer$1 = sourceMapConsumer.SourceMapConsumer;
            var SourceNode$1 = sourceNode.SourceNode;

            var sourceMap = {
            	SourceMapGenerator: SourceMapGenerator$2,
            	SourceMapConsumer: SourceMapConsumer$1,
            	SourceNode: SourceNode$1
            };

            var lookup = [];
            var revLookup = [];
            var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
            var inited = false;
            function init () {
              inited = true;
              var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
              for (var i = 0, len = code.length; i < len; ++i) {
                lookup[i] = code[i];
                revLookup[code.charCodeAt(i)] = i;
              }

              revLookup['-'.charCodeAt(0)] = 62;
              revLookup['_'.charCodeAt(0)] = 63;
            }

            function toByteArray (b64) {
              if (!inited) {
                init();
              }
              var i, j, l, tmp, placeHolders, arr;
              var len = b64.length;

              if (len % 4 > 0) {
                throw new Error('Invalid string. Length must be a multiple of 4')
              }

              // the number of equal signs (place holders)
              // if there are two placeholders, than the two characters before it
              // represent one byte
              // if there is only one, then the three characters before it represent 2 bytes
              // this is just a cheap hack to not do indexOf twice
              placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;

              // base64 is 4/3 + up to two characters of the original data
              arr = new Arr(len * 3 / 4 - placeHolders);

              // if there are placeholders, only get up to the last complete 4 chars
              l = placeHolders > 0 ? len - 4 : len;

              var L = 0;

              for (i = 0, j = 0; i < l; i += 4, j += 3) {
                tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
                arr[L++] = (tmp >> 16) & 0xFF;
                arr[L++] = (tmp >> 8) & 0xFF;
                arr[L++] = tmp & 0xFF;
              }

              if (placeHolders === 2) {
                tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
                arr[L++] = tmp & 0xFF;
              } else if (placeHolders === 1) {
                tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
                arr[L++] = (tmp >> 8) & 0xFF;
                arr[L++] = tmp & 0xFF;
              }

              return arr
            }

            function tripletToBase64 (num) {
              return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
            }

            function encodeChunk (uint8, start, end) {
              var tmp;
              var output = [];
              for (var i = start; i < end; i += 3) {
                tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
                output.push(tripletToBase64(tmp));
              }
              return output.join('')
            }

            function fromByteArray (uint8) {
              if (!inited) {
                init();
              }
              var tmp;
              var len = uint8.length;
              var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
              var output = '';
              var parts = [];
              var maxChunkLength = 16383; // must be multiple of 3

              // go through the array every three bytes, we'll deal with trailing stuff later
              for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
                parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
              }

              // pad the end with zeros, but make sure to not forget the extra bytes
              if (extraBytes === 1) {
                tmp = uint8[len - 1];
                output += lookup[tmp >> 2];
                output += lookup[(tmp << 4) & 0x3F];
                output += '==';
              } else if (extraBytes === 2) {
                tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
                output += lookup[tmp >> 10];
                output += lookup[(tmp >> 4) & 0x3F];
                output += lookup[(tmp << 2) & 0x3F];
                output += '=';
              }

              parts.push(output);

              return parts.join('')
            }

            function read (buffer, offset, isLE, mLen, nBytes) {
              var e, m;
              var eLen = nBytes * 8 - mLen - 1;
              var eMax = (1 << eLen) - 1;
              var eBias = eMax >> 1;
              var nBits = -7;
              var i = isLE ? (nBytes - 1) : 0;
              var d = isLE ? -1 : 1;
              var s = buffer[offset + i];

              i += d;

              e = s & ((1 << (-nBits)) - 1);
              s >>= (-nBits);
              nBits += eLen;
              for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

              m = e & ((1 << (-nBits)) - 1);
              e >>= (-nBits);
              nBits += mLen;
              for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

              if (e === 0) {
                e = 1 - eBias;
              } else if (e === eMax) {
                return m ? NaN : ((s ? -1 : 1) * Infinity)
              } else {
                m = m + Math.pow(2, mLen);
                e = e - eBias;
              }
              return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
            }

            function write (buffer, value, offset, isLE, mLen, nBytes) {
              var e, m, c;
              var eLen = nBytes * 8 - mLen - 1;
              var eMax = (1 << eLen) - 1;
              var eBias = eMax >> 1;
              var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
              var i = isLE ? 0 : (nBytes - 1);
              var d = isLE ? 1 : -1;
              var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

              value = Math.abs(value);

              if (isNaN(value) || value === Infinity) {
                m = isNaN(value) ? 1 : 0;
                e = eMax;
              } else {
                e = Math.floor(Math.log(value) / Math.LN2);
                if (value * (c = Math.pow(2, -e)) < 1) {
                  e--;
                  c *= 2;
                }
                if (e + eBias >= 1) {
                  value += rt / c;
                } else {
                  value += rt * Math.pow(2, 1 - eBias);
                }
                if (value * c >= 2) {
                  e++;
                  c /= 2;
                }

                if (e + eBias >= eMax) {
                  m = 0;
                  e = eMax;
                } else if (e + eBias >= 1) {
                  m = (value * c - 1) * Math.pow(2, mLen);
                  e = e + eBias;
                } else {
                  m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
                  e = 0;
                }
              }

              for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

              e = (e << mLen) | m;
              eLen += mLen;
              for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

              buffer[offset + i - d] |= s * 128;
            }

            var toString = {}.toString;

            var isArray = Array.isArray || function (arr) {
              return toString.call(arr) == '[object Array]';
            };

            var INSPECT_MAX_BYTES = 50;

            /**
             * If `Buffer.TYPED_ARRAY_SUPPORT`:
             *   === true    Use Uint8Array implementation (fastest)
             *   === false   Use Object implementation (most compatible, even IE6)
             *
             * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
             * Opera 11.6+, iOS 4.2+.
             *
             * Due to various browser bugs, sometimes the Object implementation will be used even
             * when the browser supports typed arrays.
             *
             * Note:
             *
             *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
             *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
             *
             *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
             *
             *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
             *     incorrect length in some situations.

             * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
             * get the Object implementation, which is slower but behaves correctly.
             */
            Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
              ? global$1.TYPED_ARRAY_SUPPORT
              : true;

            function kMaxLength () {
              return Buffer.TYPED_ARRAY_SUPPORT
                ? 0x7fffffff
                : 0x3fffffff
            }

            function createBuffer (that, length) {
              if (kMaxLength() < length) {
                throw new RangeError('Invalid typed array length')
              }
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                // Return an augmented `Uint8Array` instance, for best performance
                that = new Uint8Array(length);
                that.__proto__ = Buffer.prototype;
              } else {
                // Fallback: Return an object instance of the Buffer class
                if (that === null) {
                  that = new Buffer(length);
                }
                that.length = length;
              }

              return that
            }

            /**
             * The Buffer constructor returns instances of `Uint8Array` that have their
             * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
             * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
             * and the `Uint8Array` methods. Square bracket notation works as expected -- it
             * returns a single octet.
             *
             * The `Uint8Array` prototype remains unmodified.
             */

            function Buffer (arg, encodingOrOffset, length) {
              if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
                return new Buffer(arg, encodingOrOffset, length)
              }

              // Common case.
              if (typeof arg === 'number') {
                if (typeof encodingOrOffset === 'string') {
                  throw new Error(
                    'If encoding is specified then the first argument must be a string'
                  )
                }
                return allocUnsafe(this, arg)
              }
              return from(this, arg, encodingOrOffset, length)
            }

            Buffer.poolSize = 8192; // not used by this implementation

            // TODO: Legacy, not needed anymore. Remove in next major version.
            Buffer._augment = function (arr) {
              arr.__proto__ = Buffer.prototype;
              return arr
            };

            function from (that, value, encodingOrOffset, length) {
              if (typeof value === 'number') {
                throw new TypeError('"value" argument must not be a number')
              }

              if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
                return fromArrayBuffer(that, value, encodingOrOffset, length)
              }

              if (typeof value === 'string') {
                return fromString(that, value, encodingOrOffset)
              }

              return fromObject(that, value)
            }

            /**
             * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
             * if value is a number.
             * Buffer.from(str[, encoding])
             * Buffer.from(array)
             * Buffer.from(buffer)
             * Buffer.from(arrayBuffer[, byteOffset[, length]])
             **/
            Buffer.from = function (value, encodingOrOffset, length) {
              return from(null, value, encodingOrOffset, length)
            };

            if (Buffer.TYPED_ARRAY_SUPPORT) {
              Buffer.prototype.__proto__ = Uint8Array.prototype;
              Buffer.__proto__ = Uint8Array;
            }

            function assertSize (size) {
              if (typeof size !== 'number') {
                throw new TypeError('"size" argument must be a number')
              } else if (size < 0) {
                throw new RangeError('"size" argument must not be negative')
              }
            }

            function alloc (that, size, fill, encoding) {
              assertSize(size);
              if (size <= 0) {
                return createBuffer(that, size)
              }
              if (fill !== undefined) {
                // Only pay attention to encoding if it's a string. This
                // prevents accidentally sending in a number that would
                // be interpretted as a start offset.
                return typeof encoding === 'string'
                  ? createBuffer(that, size).fill(fill, encoding)
                  : createBuffer(that, size).fill(fill)
              }
              return createBuffer(that, size)
            }

            /**
             * Creates a new filled Buffer instance.
             * alloc(size[, fill[, encoding]])
             **/
            Buffer.alloc = function (size, fill, encoding) {
              return alloc(null, size, fill, encoding)
            };

            function allocUnsafe (that, size) {
              assertSize(size);
              that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
              if (!Buffer.TYPED_ARRAY_SUPPORT) {
                for (var i = 0; i < size; ++i) {
                  that[i] = 0;
                }
              }
              return that
            }

            /**
             * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
             * */
            Buffer.allocUnsafe = function (size) {
              return allocUnsafe(null, size)
            };
            /**
             * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
             */
            Buffer.allocUnsafeSlow = function (size) {
              return allocUnsafe(null, size)
            };

            function fromString (that, string, encoding) {
              if (typeof encoding !== 'string' || encoding === '') {
                encoding = 'utf8';
              }

              if (!Buffer.isEncoding(encoding)) {
                throw new TypeError('"encoding" must be a valid string encoding')
              }

              var length = byteLength(string, encoding) | 0;
              that = createBuffer(that, length);

              var actual = that.write(string, encoding);

              if (actual !== length) {
                // Writing a hex string, for example, that contains invalid characters will
                // cause everything after the first invalid character to be ignored. (e.g.
                // 'abxxcd' will be treated as 'ab')
                that = that.slice(0, actual);
              }

              return that
            }

            function fromArrayLike (that, array) {
              var length = array.length < 0 ? 0 : checked(array.length) | 0;
              that = createBuffer(that, length);
              for (var i = 0; i < length; i += 1) {
                that[i] = array[i] & 255;
              }
              return that
            }

            function fromArrayBuffer (that, array, byteOffset, length) {
              array.byteLength; // this throws if `array` is not a valid ArrayBuffer

              if (byteOffset < 0 || array.byteLength < byteOffset) {
                throw new RangeError('\'offset\' is out of bounds')
              }

              if (array.byteLength < byteOffset + (length || 0)) {
                throw new RangeError('\'length\' is out of bounds')
              }

              if (byteOffset === undefined && length === undefined) {
                array = new Uint8Array(array);
              } else if (length === undefined) {
                array = new Uint8Array(array, byteOffset);
              } else {
                array = new Uint8Array(array, byteOffset, length);
              }

              if (Buffer.TYPED_ARRAY_SUPPORT) {
                // Return an augmented `Uint8Array` instance, for best performance
                that = array;
                that.__proto__ = Buffer.prototype;
              } else {
                // Fallback: Return an object instance of the Buffer class
                that = fromArrayLike(that, array);
              }
              return that
            }

            function fromObject (that, obj) {
              if (internalIsBuffer(obj)) {
                var len = checked(obj.length) | 0;
                that = createBuffer(that, len);

                if (that.length === 0) {
                  return that
                }

                obj.copy(that, 0, 0, len);
                return that
              }

              if (obj) {
                if ((typeof ArrayBuffer !== 'undefined' &&
                    obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
                  if (typeof obj.length !== 'number' || isnan(obj.length)) {
                    return createBuffer(that, 0)
                  }
                  return fromArrayLike(that, obj)
                }

                if (obj.type === 'Buffer' && isArray(obj.data)) {
                  return fromArrayLike(that, obj.data)
                }
              }

              throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
            }

            function checked (length) {
              // Note: cannot use `length < kMaxLength()` here because that fails when
              // length is NaN (which is otherwise coerced to zero.)
              if (length >= kMaxLength()) {
                throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                                     'size: 0x' + kMaxLength().toString(16) + ' bytes')
              }
              return length | 0
            }
            Buffer.isBuffer = isBuffer;
            function internalIsBuffer (b) {
              return !!(b != null && b._isBuffer)
            }

            Buffer.compare = function compare (a, b) {
              if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
                throw new TypeError('Arguments must be Buffers')
              }

              if (a === b) return 0

              var x = a.length;
              var y = b.length;

              for (var i = 0, len = Math.min(x, y); i < len; ++i) {
                if (a[i] !== b[i]) {
                  x = a[i];
                  y = b[i];
                  break
                }
              }

              if (x < y) return -1
              if (y < x) return 1
              return 0
            };

            Buffer.isEncoding = function isEncoding (encoding) {
              switch (String(encoding).toLowerCase()) {
                case 'hex':
                case 'utf8':
                case 'utf-8':
                case 'ascii':
                case 'latin1':
                case 'binary':
                case 'base64':
                case 'ucs2':
                case 'ucs-2':
                case 'utf16le':
                case 'utf-16le':
                  return true
                default:
                  return false
              }
            };

            Buffer.concat = function concat (list, length) {
              if (!isArray(list)) {
                throw new TypeError('"list" argument must be an Array of Buffers')
              }

              if (list.length === 0) {
                return Buffer.alloc(0)
              }

              var i;
              if (length === undefined) {
                length = 0;
                for (i = 0; i < list.length; ++i) {
                  length += list[i].length;
                }
              }

              var buffer = Buffer.allocUnsafe(length);
              var pos = 0;
              for (i = 0; i < list.length; ++i) {
                var buf = list[i];
                if (!internalIsBuffer(buf)) {
                  throw new TypeError('"list" argument must be an Array of Buffers')
                }
                buf.copy(buffer, pos);
                pos += buf.length;
              }
              return buffer
            };

            function byteLength (string, encoding) {
              if (internalIsBuffer(string)) {
                return string.length
              }
              if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
                  (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
                return string.byteLength
              }
              if (typeof string !== 'string') {
                string = '' + string;
              }

              var len = string.length;
              if (len === 0) return 0

              // Use a for loop to avoid recursion
              var loweredCase = false;
              for (;;) {
                switch (encoding) {
                  case 'ascii':
                  case 'latin1':
                  case 'binary':
                    return len
                  case 'utf8':
                  case 'utf-8':
                  case undefined:
                    return utf8ToBytes(string).length
                  case 'ucs2':
                  case 'ucs-2':
                  case 'utf16le':
                  case 'utf-16le':
                    return len * 2
                  case 'hex':
                    return len >>> 1
                  case 'base64':
                    return base64ToBytes(string).length
                  default:
                    if (loweredCase) return utf8ToBytes(string).length // assume utf8
                    encoding = ('' + encoding).toLowerCase();
                    loweredCase = true;
                }
              }
            }
            Buffer.byteLength = byteLength;

            function slowToString (encoding, start, end) {
              var loweredCase = false;

              // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
              // property of a typed array.

              // This behaves neither like String nor Uint8Array in that we set start/end
              // to their upper/lower bounds if the value passed is out of range.
              // undefined is handled specially as per ECMA-262 6th Edition,
              // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
              if (start === undefined || start < 0) {
                start = 0;
              }
              // Return early if start > this.length. Done here to prevent potential uint32
              // coercion fail below.
              if (start > this.length) {
                return ''
              }

              if (end === undefined || end > this.length) {
                end = this.length;
              }

              if (end <= 0) {
                return ''
              }

              // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
              end >>>= 0;
              start >>>= 0;

              if (end <= start) {
                return ''
              }

              if (!encoding) encoding = 'utf8';

              while (true) {
                switch (encoding) {
                  case 'hex':
                    return hexSlice(this, start, end)

                  case 'utf8':
                  case 'utf-8':
                    return utf8Slice(this, start, end)

                  case 'ascii':
                    return asciiSlice(this, start, end)

                  case 'latin1':
                  case 'binary':
                    return latin1Slice(this, start, end)

                  case 'base64':
                    return base64Slice(this, start, end)

                  case 'ucs2':
                  case 'ucs-2':
                  case 'utf16le':
                  case 'utf-16le':
                    return utf16leSlice(this, start, end)

                  default:
                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                    encoding = (encoding + '').toLowerCase();
                    loweredCase = true;
                }
              }
            }

            // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
            // Buffer instances.
            Buffer.prototype._isBuffer = true;

            function swap$1 (b, n, m) {
              var i = b[n];
              b[n] = b[m];
              b[m] = i;
            }

            Buffer.prototype.swap16 = function swap16 () {
              var len = this.length;
              if (len % 2 !== 0) {
                throw new RangeError('Buffer size must be a multiple of 16-bits')
              }
              for (var i = 0; i < len; i += 2) {
                swap$1(this, i, i + 1);
              }
              return this
            };

            Buffer.prototype.swap32 = function swap32 () {
              var len = this.length;
              if (len % 4 !== 0) {
                throw new RangeError('Buffer size must be a multiple of 32-bits')
              }
              for (var i = 0; i < len; i += 4) {
                swap$1(this, i, i + 3);
                swap$1(this, i + 1, i + 2);
              }
              return this
            };

            Buffer.prototype.swap64 = function swap64 () {
              var len = this.length;
              if (len % 8 !== 0) {
                throw new RangeError('Buffer size must be a multiple of 64-bits')
              }
              for (var i = 0; i < len; i += 8) {
                swap$1(this, i, i + 7);
                swap$1(this, i + 1, i + 6);
                swap$1(this, i + 2, i + 5);
                swap$1(this, i + 3, i + 4);
              }
              return this
            };

            Buffer.prototype.toString = function toString () {
              var length = this.length | 0;
              if (length === 0) return ''
              if (arguments.length === 0) return utf8Slice(this, 0, length)
              return slowToString.apply(this, arguments)
            };

            Buffer.prototype.equals = function equals (b) {
              if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
              if (this === b) return true
              return Buffer.compare(this, b) === 0
            };

            Buffer.prototype.inspect = function inspect () {
              var str = '';
              var max = INSPECT_MAX_BYTES;
              if (this.length > 0) {
                str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
                if (this.length > max) str += ' ... ';
              }
              return '<Buffer ' + str + '>'
            };

            Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
              if (!internalIsBuffer(target)) {
                throw new TypeError('Argument must be a Buffer')
              }

              if (start === undefined) {
                start = 0;
              }
              if (end === undefined) {
                end = target ? target.length : 0;
              }
              if (thisStart === undefined) {
                thisStart = 0;
              }
              if (thisEnd === undefined) {
                thisEnd = this.length;
              }

              if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
                throw new RangeError('out of range index')
              }

              if (thisStart >= thisEnd && start >= end) {
                return 0
              }
              if (thisStart >= thisEnd) {
                return -1
              }
              if (start >= end) {
                return 1
              }

              start >>>= 0;
              end >>>= 0;
              thisStart >>>= 0;
              thisEnd >>>= 0;

              if (this === target) return 0

              var x = thisEnd - thisStart;
              var y = end - start;
              var len = Math.min(x, y);

              var thisCopy = this.slice(thisStart, thisEnd);
              var targetCopy = target.slice(start, end);

              for (var i = 0; i < len; ++i) {
                if (thisCopy[i] !== targetCopy[i]) {
                  x = thisCopy[i];
                  y = targetCopy[i];
                  break
                }
              }

              if (x < y) return -1
              if (y < x) return 1
              return 0
            };

            // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
            // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
            //
            // Arguments:
            // - buffer - a Buffer to search
            // - val - a string, Buffer, or number
            // - byteOffset - an index into `buffer`; will be clamped to an int32
            // - encoding - an optional encoding, relevant is val is a string
            // - dir - true for indexOf, false for lastIndexOf
            function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
              // Empty buffer means no match
              if (buffer.length === 0) return -1

              // Normalize byteOffset
              if (typeof byteOffset === 'string') {
                encoding = byteOffset;
                byteOffset = 0;
              } else if (byteOffset > 0x7fffffff) {
                byteOffset = 0x7fffffff;
              } else if (byteOffset < -0x80000000) {
                byteOffset = -0x80000000;
              }
              byteOffset = +byteOffset;  // Coerce to Number.
              if (isNaN(byteOffset)) {
                // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
                byteOffset = dir ? 0 : (buffer.length - 1);
              }

              // Normalize byteOffset: negative offsets start from the end of the buffer
              if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
              if (byteOffset >= buffer.length) {
                if (dir) return -1
                else byteOffset = buffer.length - 1;
              } else if (byteOffset < 0) {
                if (dir) byteOffset = 0;
                else return -1
              }

              // Normalize val
              if (typeof val === 'string') {
                val = Buffer.from(val, encoding);
              }

              // Finally, search either indexOf (if dir is true) or lastIndexOf
              if (internalIsBuffer(val)) {
                // Special case: looking for empty string/buffer always fails
                if (val.length === 0) {
                  return -1
                }
                return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
              } else if (typeof val === 'number') {
                val = val & 0xFF; // Search for a byte value [0-255]
                if (Buffer.TYPED_ARRAY_SUPPORT &&
                    typeof Uint8Array.prototype.indexOf === 'function') {
                  if (dir) {
                    return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
                  } else {
                    return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
                  }
                }
                return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
              }

              throw new TypeError('val must be string, number or Buffer')
            }

            function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
              var indexSize = 1;
              var arrLength = arr.length;
              var valLength = val.length;

              if (encoding !== undefined) {
                encoding = String(encoding).toLowerCase();
                if (encoding === 'ucs2' || encoding === 'ucs-2' ||
                    encoding === 'utf16le' || encoding === 'utf-16le') {
                  if (arr.length < 2 || val.length < 2) {
                    return -1
                  }
                  indexSize = 2;
                  arrLength /= 2;
                  valLength /= 2;
                  byteOffset /= 2;
                }
              }

              function read (buf, i) {
                if (indexSize === 1) {
                  return buf[i]
                } else {
                  return buf.readUInt16BE(i * indexSize)
                }
              }

              var i;
              if (dir) {
                var foundIndex = -1;
                for (i = byteOffset; i < arrLength; i++) {
                  if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
                    if (foundIndex === -1) foundIndex = i;
                    if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
                  } else {
                    if (foundIndex !== -1) i -= i - foundIndex;
                    foundIndex = -1;
                  }
                }
              } else {
                if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
                for (i = byteOffset; i >= 0; i--) {
                  var found = true;
                  for (var j = 0; j < valLength; j++) {
                    if (read(arr, i + j) !== read(val, j)) {
                      found = false;
                      break
                    }
                  }
                  if (found) return i
                }
              }

              return -1
            }

            Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
              return this.indexOf(val, byteOffset, encoding) !== -1
            };

            Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
              return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
            };

            Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
              return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
            };

            function hexWrite (buf, string, offset, length) {
              offset = Number(offset) || 0;
              var remaining = buf.length - offset;
              if (!length) {
                length = remaining;
              } else {
                length = Number(length);
                if (length > remaining) {
                  length = remaining;
                }
              }

              // must be an even number of digits
              var strLen = string.length;
              if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

              if (length > strLen / 2) {
                length = strLen / 2;
              }
              for (var i = 0; i < length; ++i) {
                var parsed = parseInt(string.substr(i * 2, 2), 16);
                if (isNaN(parsed)) return i
                buf[offset + i] = parsed;
              }
              return i
            }

            function utf8Write (buf, string, offset, length) {
              return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
            }

            function asciiWrite (buf, string, offset, length) {
              return blitBuffer(asciiToBytes(string), buf, offset, length)
            }

            function latin1Write (buf, string, offset, length) {
              return asciiWrite(buf, string, offset, length)
            }

            function base64Write (buf, string, offset, length) {
              return blitBuffer(base64ToBytes(string), buf, offset, length)
            }

            function ucs2Write (buf, string, offset, length) {
              return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
            }

            Buffer.prototype.write = function write (string, offset, length, encoding) {
              // Buffer#write(string)
              if (offset === undefined) {
                encoding = 'utf8';
                length = this.length;
                offset = 0;
              // Buffer#write(string, encoding)
              } else if (length === undefined && typeof offset === 'string') {
                encoding = offset;
                length = this.length;
                offset = 0;
              // Buffer#write(string, offset[, length][, encoding])
              } else if (isFinite(offset)) {
                offset = offset | 0;
                if (isFinite(length)) {
                  length = length | 0;
                  if (encoding === undefined) encoding = 'utf8';
                } else {
                  encoding = length;
                  length = undefined;
                }
              // legacy write(string, encoding, offset, length) - remove in v0.13
              } else {
                throw new Error(
                  'Buffer.write(string, encoding, offset[, length]) is no longer supported'
                )
              }

              var remaining = this.length - offset;
              if (length === undefined || length > remaining) length = remaining;

              if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
                throw new RangeError('Attempt to write outside buffer bounds')
              }

              if (!encoding) encoding = 'utf8';

              var loweredCase = false;
              for (;;) {
                switch (encoding) {
                  case 'hex':
                    return hexWrite(this, string, offset, length)

                  case 'utf8':
                  case 'utf-8':
                    return utf8Write(this, string, offset, length)

                  case 'ascii':
                    return asciiWrite(this, string, offset, length)

                  case 'latin1':
                  case 'binary':
                    return latin1Write(this, string, offset, length)

                  case 'base64':
                    // Warning: maxLength not taken into account in base64Write
                    return base64Write(this, string, offset, length)

                  case 'ucs2':
                  case 'ucs-2':
                  case 'utf16le':
                  case 'utf-16le':
                    return ucs2Write(this, string, offset, length)

                  default:
                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                    encoding = ('' + encoding).toLowerCase();
                    loweredCase = true;
                }
              }
            };

            Buffer.prototype.toJSON = function toJSON () {
              return {
                type: 'Buffer',
                data: Array.prototype.slice.call(this._arr || this, 0)
              }
            };

            function base64Slice (buf, start, end) {
              if (start === 0 && end === buf.length) {
                return fromByteArray(buf)
              } else {
                return fromByteArray(buf.slice(start, end))
              }
            }

            function utf8Slice (buf, start, end) {
              end = Math.min(buf.length, end);
              var res = [];

              var i = start;
              while (i < end) {
                var firstByte = buf[i];
                var codePoint = null;
                var bytesPerSequence = (firstByte > 0xEF) ? 4
                  : (firstByte > 0xDF) ? 3
                  : (firstByte > 0xBF) ? 2
                  : 1;

                if (i + bytesPerSequence <= end) {
                  var secondByte, thirdByte, fourthByte, tempCodePoint;

                  switch (bytesPerSequence) {
                    case 1:
                      if (firstByte < 0x80) {
                        codePoint = firstByte;
                      }
                      break
                    case 2:
                      secondByte = buf[i + 1];
                      if ((secondByte & 0xC0) === 0x80) {
                        tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
                        if (tempCodePoint > 0x7F) {
                          codePoint = tempCodePoint;
                        }
                      }
                      break
                    case 3:
                      secondByte = buf[i + 1];
                      thirdByte = buf[i + 2];
                      if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                        tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
                        if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                          codePoint = tempCodePoint;
                        }
                      }
                      break
                    case 4:
                      secondByte = buf[i + 1];
                      thirdByte = buf[i + 2];
                      fourthByte = buf[i + 3];
                      if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                        tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
                        if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                          codePoint = tempCodePoint;
                        }
                      }
                  }
                }

                if (codePoint === null) {
                  // we did not generate a valid codePoint so insert a
                  // replacement char (U+FFFD) and advance only 1 byte
                  codePoint = 0xFFFD;
                  bytesPerSequence = 1;
                } else if (codePoint > 0xFFFF) {
                  // encode to utf16 (surrogate pair dance)
                  codePoint -= 0x10000;
                  res.push(codePoint >>> 10 & 0x3FF | 0xD800);
                  codePoint = 0xDC00 | codePoint & 0x3FF;
                }

                res.push(codePoint);
                i += bytesPerSequence;
              }

              return decodeCodePointsArray(res)
            }

            // Based on http://stackoverflow.com/a/22747272/680742, the browser with
            // the lowest limit is Chrome, with 0x10000 args.
            // We go 1 magnitude less, for safety
            var MAX_ARGUMENTS_LENGTH = 0x1000;

            function decodeCodePointsArray (codePoints) {
              var len = codePoints.length;
              if (len <= MAX_ARGUMENTS_LENGTH) {
                return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
              }

              // Decode in chunks to avoid "call stack size exceeded".
              var res = '';
              var i = 0;
              while (i < len) {
                res += String.fromCharCode.apply(
                  String,
                  codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
                );
              }
              return res
            }

            function asciiSlice (buf, start, end) {
              var ret = '';
              end = Math.min(buf.length, end);

              for (var i = start; i < end; ++i) {
                ret += String.fromCharCode(buf[i] & 0x7F);
              }
              return ret
            }

            function latin1Slice (buf, start, end) {
              var ret = '';
              end = Math.min(buf.length, end);

              for (var i = start; i < end; ++i) {
                ret += String.fromCharCode(buf[i]);
              }
              return ret
            }

            function hexSlice (buf, start, end) {
              var len = buf.length;

              if (!start || start < 0) start = 0;
              if (!end || end < 0 || end > len) end = len;

              var out = '';
              for (var i = start; i < end; ++i) {
                out += toHex(buf[i]);
              }
              return out
            }

            function utf16leSlice (buf, start, end) {
              var bytes = buf.slice(start, end);
              var res = '';
              for (var i = 0; i < bytes.length; i += 2) {
                res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
              }
              return res
            }

            Buffer.prototype.slice = function slice (start, end) {
              var len = this.length;
              start = ~~start;
              end = end === undefined ? len : ~~end;

              if (start < 0) {
                start += len;
                if (start < 0) start = 0;
              } else if (start > len) {
                start = len;
              }

              if (end < 0) {
                end += len;
                if (end < 0) end = 0;
              } else if (end > len) {
                end = len;
              }

              if (end < start) end = start;

              var newBuf;
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                newBuf = this.subarray(start, end);
                newBuf.__proto__ = Buffer.prototype;
              } else {
                var sliceLen = end - start;
                newBuf = new Buffer(sliceLen, undefined);
                for (var i = 0; i < sliceLen; ++i) {
                  newBuf[i] = this[i + start];
                }
              }

              return newBuf
            };

            /*
             * Need to make sure that buffer isn't trying to write out of bounds.
             */
            function checkOffset (offset, ext, length) {
              if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
              if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
            }

            Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) checkOffset(offset, byteLength, this.length);

              var val = this[offset];
              var mul = 1;
              var i = 0;
              while (++i < byteLength && (mul *= 0x100)) {
                val += this[offset + i] * mul;
              }

              return val
            };

            Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) {
                checkOffset(offset, byteLength, this.length);
              }

              var val = this[offset + --byteLength];
              var mul = 1;
              while (byteLength > 0 && (mul *= 0x100)) {
                val += this[offset + --byteLength] * mul;
              }

              return val
            };

            Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 1, this.length);
              return this[offset]
            };

            Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 2, this.length);
              return this[offset] | (this[offset + 1] << 8)
            };

            Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 2, this.length);
              return (this[offset] << 8) | this[offset + 1]
            };

            Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);

              return ((this[offset]) |
                  (this[offset + 1] << 8) |
                  (this[offset + 2] << 16)) +
                  (this[offset + 3] * 0x1000000)
            };

            Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);

              return (this[offset] * 0x1000000) +
                ((this[offset + 1] << 16) |
                (this[offset + 2] << 8) |
                this[offset + 3])
            };

            Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) checkOffset(offset, byteLength, this.length);

              var val = this[offset];
              var mul = 1;
              var i = 0;
              while (++i < byteLength && (mul *= 0x100)) {
                val += this[offset + i] * mul;
              }
              mul *= 0x80;

              if (val >= mul) val -= Math.pow(2, 8 * byteLength);

              return val
            };

            Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) checkOffset(offset, byteLength, this.length);

              var i = byteLength;
              var mul = 1;
              var val = this[offset + --i];
              while (i > 0 && (mul *= 0x100)) {
                val += this[offset + --i] * mul;
              }
              mul *= 0x80;

              if (val >= mul) val -= Math.pow(2, 8 * byteLength);

              return val
            };

            Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 1, this.length);
              if (!(this[offset] & 0x80)) return (this[offset])
              return ((0xff - this[offset] + 1) * -1)
            };

            Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 2, this.length);
              var val = this[offset] | (this[offset + 1] << 8);
              return (val & 0x8000) ? val | 0xFFFF0000 : val
            };

            Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 2, this.length);
              var val = this[offset + 1] | (this[offset] << 8);
              return (val & 0x8000) ? val | 0xFFFF0000 : val
            };

            Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);

              return (this[offset]) |
                (this[offset + 1] << 8) |
                (this[offset + 2] << 16) |
                (this[offset + 3] << 24)
            };

            Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);

              return (this[offset] << 24) |
                (this[offset + 1] << 16) |
                (this[offset + 2] << 8) |
                (this[offset + 3])
            };

            Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);
              return read(this, offset, true, 23, 4)
            };

            Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 4, this.length);
              return read(this, offset, false, 23, 4)
            };

            Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 8, this.length);
              return read(this, offset, true, 52, 8)
            };

            Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
              if (!noAssert) checkOffset(offset, 8, this.length);
              return read(this, offset, false, 52, 8)
            };

            function checkInt (buf, value, offset, ext, max, min) {
              if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
              if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
              if (offset + ext > buf.length) throw new RangeError('Index out of range')
            }

            Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
              value = +value;
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) {
                var maxBytes = Math.pow(2, 8 * byteLength) - 1;
                checkInt(this, value, offset, byteLength, maxBytes, 0);
              }

              var mul = 1;
              var i = 0;
              this[offset] = value & 0xFF;
              while (++i < byteLength && (mul *= 0x100)) {
                this[offset + i] = (value / mul) & 0xFF;
              }

              return offset + byteLength
            };

            Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
              value = +value;
              offset = offset | 0;
              byteLength = byteLength | 0;
              if (!noAssert) {
                var maxBytes = Math.pow(2, 8 * byteLength) - 1;
                checkInt(this, value, offset, byteLength, maxBytes, 0);
              }

              var i = byteLength - 1;
              var mul = 1;
              this[offset + i] = value & 0xFF;
              while (--i >= 0 && (mul *= 0x100)) {
                this[offset + i] = (value / mul) & 0xFF;
              }

              return offset + byteLength
            };

            Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
              if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
              this[offset] = (value & 0xff);
              return offset + 1
            };

            function objectWriteUInt16 (buf, value, offset, littleEndian) {
              if (value < 0) value = 0xffff + value + 1;
              for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
                buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
                  (littleEndian ? i : 1 - i) * 8;
              }
            }

            Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value & 0xff);
                this[offset + 1] = (value >>> 8);
              } else {
                objectWriteUInt16(this, value, offset, true);
              }
              return offset + 2
            };

            Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value >>> 8);
                this[offset + 1] = (value & 0xff);
              } else {
                objectWriteUInt16(this, value, offset, false);
              }
              return offset + 2
            };

            function objectWriteUInt32 (buf, value, offset, littleEndian) {
              if (value < 0) value = 0xffffffff + value + 1;
              for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
                buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
              }
            }

            Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset + 3] = (value >>> 24);
                this[offset + 2] = (value >>> 16);
                this[offset + 1] = (value >>> 8);
                this[offset] = (value & 0xff);
              } else {
                objectWriteUInt32(this, value, offset, true);
              }
              return offset + 4
            };

            Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value >>> 24);
                this[offset + 1] = (value >>> 16);
                this[offset + 2] = (value >>> 8);
                this[offset + 3] = (value & 0xff);
              } else {
                objectWriteUInt32(this, value, offset, false);
              }
              return offset + 4
            };

            Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) {
                var limit = Math.pow(2, 8 * byteLength - 1);

                checkInt(this, value, offset, byteLength, limit - 1, -limit);
              }

              var i = 0;
              var mul = 1;
              var sub = 0;
              this[offset] = value & 0xFF;
              while (++i < byteLength && (mul *= 0x100)) {
                if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
                  sub = 1;
                }
                this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
              }

              return offset + byteLength
            };

            Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) {
                var limit = Math.pow(2, 8 * byteLength - 1);

                checkInt(this, value, offset, byteLength, limit - 1, -limit);
              }

              var i = byteLength - 1;
              var mul = 1;
              var sub = 0;
              this[offset + i] = value & 0xFF;
              while (--i >= 0 && (mul *= 0x100)) {
                if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
                  sub = 1;
                }
                this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
              }

              return offset + byteLength
            };

            Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
              if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
              if (value < 0) value = 0xff + value + 1;
              this[offset] = (value & 0xff);
              return offset + 1
            };

            Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value & 0xff);
                this[offset + 1] = (value >>> 8);
              } else {
                objectWriteUInt16(this, value, offset, true);
              }
              return offset + 2
            };

            Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value >>> 8);
                this[offset + 1] = (value & 0xff);
              } else {
                objectWriteUInt16(this, value, offset, false);
              }
              return offset + 2
            };

            Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value & 0xff);
                this[offset + 1] = (value >>> 8);
                this[offset + 2] = (value >>> 16);
                this[offset + 3] = (value >>> 24);
              } else {
                objectWriteUInt32(this, value, offset, true);
              }
              return offset + 4
            };

            Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
              value = +value;
              offset = offset | 0;
              if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
              if (value < 0) value = 0xffffffff + value + 1;
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                this[offset] = (value >>> 24);
                this[offset + 1] = (value >>> 16);
                this[offset + 2] = (value >>> 8);
                this[offset + 3] = (value & 0xff);
              } else {
                objectWriteUInt32(this, value, offset, false);
              }
              return offset + 4
            };

            function checkIEEE754 (buf, value, offset, ext, max, min) {
              if (offset + ext > buf.length) throw new RangeError('Index out of range')
              if (offset < 0) throw new RangeError('Index out of range')
            }

            function writeFloat (buf, value, offset, littleEndian, noAssert) {
              if (!noAssert) {
                checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
              }
              write(buf, value, offset, littleEndian, 23, 4);
              return offset + 4
            }

            Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
              return writeFloat(this, value, offset, true, noAssert)
            };

            Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
              return writeFloat(this, value, offset, false, noAssert)
            };

            function writeDouble (buf, value, offset, littleEndian, noAssert) {
              if (!noAssert) {
                checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
              }
              write(buf, value, offset, littleEndian, 52, 8);
              return offset + 8
            }

            Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
              return writeDouble(this, value, offset, true, noAssert)
            };

            Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
              return writeDouble(this, value, offset, false, noAssert)
            };

            // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
            Buffer.prototype.copy = function copy (target, targetStart, start, end) {
              if (!start) start = 0;
              if (!end && end !== 0) end = this.length;
              if (targetStart >= target.length) targetStart = target.length;
              if (!targetStart) targetStart = 0;
              if (end > 0 && end < start) end = start;

              // Copy 0 bytes; we're done
              if (end === start) return 0
              if (target.length === 0 || this.length === 0) return 0

              // Fatal error conditions
              if (targetStart < 0) {
                throw new RangeError('targetStart out of bounds')
              }
              if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
              if (end < 0) throw new RangeError('sourceEnd out of bounds')

              // Are we oob?
              if (end > this.length) end = this.length;
              if (target.length - targetStart < end - start) {
                end = target.length - targetStart + start;
              }

              var len = end - start;
              var i;

              if (this === target && start < targetStart && targetStart < end) {
                // descending copy from end
                for (i = len - 1; i >= 0; --i) {
                  target[i + targetStart] = this[i + start];
                }
              } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
                // ascending copy from start
                for (i = 0; i < len; ++i) {
                  target[i + targetStart] = this[i + start];
                }
              } else {
                Uint8Array.prototype.set.call(
                  target,
                  this.subarray(start, start + len),
                  targetStart
                );
              }

              return len
            };

            // Usage:
            //    buffer.fill(number[, offset[, end]])
            //    buffer.fill(buffer[, offset[, end]])
            //    buffer.fill(string[, offset[, end]][, encoding])
            Buffer.prototype.fill = function fill (val, start, end, encoding) {
              // Handle string cases:
              if (typeof val === 'string') {
                if (typeof start === 'string') {
                  encoding = start;
                  start = 0;
                  end = this.length;
                } else if (typeof end === 'string') {
                  encoding = end;
                  end = this.length;
                }
                if (val.length === 1) {
                  var code = val.charCodeAt(0);
                  if (code < 256) {
                    val = code;
                  }
                }
                if (encoding !== undefined && typeof encoding !== 'string') {
                  throw new TypeError('encoding must be a string')
                }
                if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
                  throw new TypeError('Unknown encoding: ' + encoding)
                }
              } else if (typeof val === 'number') {
                val = val & 255;
              }

              // Invalid ranges are not set to a default, so can range check early.
              if (start < 0 || this.length < start || this.length < end) {
                throw new RangeError('Out of range index')
              }

              if (end <= start) {
                return this
              }

              start = start >>> 0;
              end = end === undefined ? this.length : end >>> 0;

              if (!val) val = 0;

              var i;
              if (typeof val === 'number') {
                for (i = start; i < end; ++i) {
                  this[i] = val;
                }
              } else {
                var bytes = internalIsBuffer(val)
                  ? val
                  : utf8ToBytes(new Buffer(val, encoding).toString());
                var len = bytes.length;
                for (i = 0; i < end - start; ++i) {
                  this[i + start] = bytes[i % len];
                }
              }

              return this
            };

            // HELPER FUNCTIONS
            // ================

            var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

            function base64clean (str) {
              // Node strips out invalid characters like \n and \t from the string, base64-js does not
              str = stringtrim(str).replace(INVALID_BASE64_RE, '');
              // Node converts strings with length < 2 to ''
              if (str.length < 2) return ''
              // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
              while (str.length % 4 !== 0) {
                str = str + '=';
              }
              return str
            }

            function stringtrim (str) {
              if (str.trim) return str.trim()
              return str.replace(/^\s+|\s+$/g, '')
            }

            function toHex (n) {
              if (n < 16) return '0' + n.toString(16)
              return n.toString(16)
            }

            function utf8ToBytes (string, units) {
              units = units || Infinity;
              var codePoint;
              var length = string.length;
              var leadSurrogate = null;
              var bytes = [];

              for (var i = 0; i < length; ++i) {
                codePoint = string.charCodeAt(i);

                // is surrogate component
                if (codePoint > 0xD7FF && codePoint < 0xE000) {
                  // last char was a lead
                  if (!leadSurrogate) {
                    // no lead yet
                    if (codePoint > 0xDBFF) {
                      // unexpected trail
                      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
                      continue
                    } else if (i + 1 === length) {
                      // unpaired lead
                      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
                      continue
                    }

                    // valid lead
                    leadSurrogate = codePoint;

                    continue
                  }

                  // 2 leads in a row
                  if (codePoint < 0xDC00) {
                    if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
                    leadSurrogate = codePoint;
                    continue
                  }

                  // valid surrogate pair
                  codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
                } else if (leadSurrogate) {
                  // valid bmp char, but last char was a lead
                  if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
                }

                leadSurrogate = null;

                // encode utf8
                if (codePoint < 0x80) {
                  if ((units -= 1) < 0) break
                  bytes.push(codePoint);
                } else if (codePoint < 0x800) {
                  if ((units -= 2) < 0) break
                  bytes.push(
                    codePoint >> 0x6 | 0xC0,
                    codePoint & 0x3F | 0x80
                  );
                } else if (codePoint < 0x10000) {
                  if ((units -= 3) < 0) break
                  bytes.push(
                    codePoint >> 0xC | 0xE0,
                    codePoint >> 0x6 & 0x3F | 0x80,
                    codePoint & 0x3F | 0x80
                  );
                } else if (codePoint < 0x110000) {
                  if ((units -= 4) < 0) break
                  bytes.push(
                    codePoint >> 0x12 | 0xF0,
                    codePoint >> 0xC & 0x3F | 0x80,
                    codePoint >> 0x6 & 0x3F | 0x80,
                    codePoint & 0x3F | 0x80
                  );
                } else {
                  throw new Error('Invalid code point')
                }
              }

              return bytes
            }

            function asciiToBytes (str) {
              var byteArray = [];
              for (var i = 0; i < str.length; ++i) {
                // Node's code seems to be doing this and not & 0x7F..
                byteArray.push(str.charCodeAt(i) & 0xFF);
              }
              return byteArray
            }

            function utf16leToBytes (str, units) {
              var c, hi, lo;
              var byteArray = [];
              for (var i = 0; i < str.length; ++i) {
                if ((units -= 2) < 0) break

                c = str.charCodeAt(i);
                hi = c >> 8;
                lo = c % 256;
                byteArray.push(lo);
                byteArray.push(hi);
              }

              return byteArray
            }


            function base64ToBytes (str) {
              return toByteArray(base64clean(str))
            }

            function blitBuffer (src, dst, offset, length) {
              for (var i = 0; i < length; ++i) {
                if ((i + offset >= dst.length) || (i >= src.length)) break
                dst[i + offset] = src[i];
              }
              return i
            }

            function isnan (val) {
              return val !== val // eslint-disable-line no-self-compare
            }


            // the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence
            // The _isBuffer check is for Safari 5-7 support, because it's missing
            // Object.prototype.constructor. Remove this eventually
            function isBuffer(obj) {
              return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))
            }

            function isFastBuffer (obj) {
              return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
            }

            // For Node v0.10 support. Remove this eventually.
            function isSlowBuffer (obj) {
              return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
            }

            var toString$1 = Object.prototype.toString;

            var isModern = (
              typeof Buffer.alloc === 'function' &&
              typeof Buffer.allocUnsafe === 'function' &&
              typeof Buffer.from === 'function'
            );

            function isArrayBuffer (input) {
              return toString$1.call(input).slice(8, -1) === 'ArrayBuffer'
            }

            function fromArrayBuffer$1 (obj, byteOffset, length) {
              byteOffset >>>= 0;

              var maxLength = obj.byteLength - byteOffset;

              if (maxLength < 0) {
                throw new RangeError("'offset' is out of bounds")
              }

              if (length === undefined) {
                length = maxLength;
              } else {
                length >>>= 0;

                if (length > maxLength) {
                  throw new RangeError("'length' is out of bounds")
                }
              }

              return isModern
                ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
                : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
            }

            function fromString$1 (string, encoding) {
              if (typeof encoding !== 'string' || encoding === '') {
                encoding = 'utf8';
              }

              if (!Buffer.isEncoding(encoding)) {
                throw new TypeError('"encoding" must be a valid string encoding')
              }

              return isModern
                ? Buffer.from(string, encoding)
                : new Buffer(string, encoding)
            }

            function bufferFrom (value, encodingOrOffset, length) {
              if (typeof value === 'number') {
                throw new TypeError('"value" argument must not be a number')
              }

              if (isArrayBuffer(value)) {
                return fromArrayBuffer$1(value, encodingOrOffset, length)
              }

              if (typeof value === 'string') {
                return fromString$1(value, encodingOrOffset)
              }

              return isModern
                ? Buffer.from(value)
                : new Buffer(value)
            }

            var bufferFrom_1 = bufferFrom;

            var require$$3 = ( mock_builtin && undefined ) || mock_builtin;

            var SourceMapConsumer$2 = sourceMap.SourceMapConsumer;
            var path = require$$3;

            var fs;
            try {
              fs = require$$3;
              if (!fs.existsSync || !fs.readFileSync) {
                // fs doesn't have all methods we need
                fs = null;
              }
            } catch (err) {
              /* nop */
            }



            // Only install once if called multiple times
            var errorFormatterInstalled = false;
            var uncaughtShimInstalled = false;

            // If true, the caches are reset before a stack trace formatting operation
            var emptyCacheBetweenOperations = false;

            // Supports {browser, node, auto}
            var environment = "auto";

            // Maps a file path to a string containing the file contents
            var fileContentsCache = {};

            // Maps a file path to a source map for that file
            var sourceMapCache = {};

            // Regex for detecting source maps
            var reSourceMap = /^data:application\/json[^,]+base64,/;

            // Priority list of retrieve handlers
            var retrieveFileHandlers = [];
            var retrieveMapHandlers = [];

            function isInBrowser() {
              if (environment === "browser")
                return true;
              if (environment === "node")
                return false;
              return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function') && !(window.require && window.module && window.process && window.process.type === "renderer"));
            }

            function hasGlobalProcessEventEmitter() {
              return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
            }

            function handlerExec(list) {
              return function(arg) {
                for (var i = 0; i < list.length; i++) {
                  var ret = list[i](arg);
                  if (ret) {
                    return ret;
                  }
                }
                return null;
              };
            }

            var retrieveFile = handlerExec(retrieveFileHandlers);

            retrieveFileHandlers.push(function(path) {
              // Trim the path to make sure there is no extra whitespace.
              path = path.trim();
              if (/^file:/.test(path)) {
                // existsSync/readFileSync can't handle file protocol, but once stripped, it works
                path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
                  return drive ?
                    '' : // file:///C:/dir/file -> C:/dir/file
                    '/'; // file:///root-dir/file -> /root-dir/file
                });
              }
              if (path in fileContentsCache) {
                return fileContentsCache[path];
              }

              var contents = '';
              try {
                if (!fs) {
                  // Use SJAX if we are in the browser
                  var xhr = new XMLHttpRequest();
                  xhr.open('GET', path, /** async */ false);
                  xhr.send(null);
                  if (xhr.readyState === 4 && xhr.status === 200) {
                    contents = xhr.responseText;
                  }
                } else if (fs.existsSync(path)) {
                  // Otherwise, use the filesystem
                  contents = fs.readFileSync(path, 'utf8');
                }
              } catch (er) {
                /* ignore any errors */
              }

              return fileContentsCache[path] = contents;
            });

            // Support URLs relative to a directory, but be careful about a protocol prefix
            // in case we are in the browser (i.e. directories may start with "http://" or "file:///")
            function supportRelativeURL(file, url) {
              if (!file) return url;
              var dir = path.dirname(file);
              var match = /^\w+:\/\/[^\/]*/.exec(dir);
              var protocol = match ? match[0] : '';
              var startPath = dir.slice(protocol.length);
              if (protocol && /^\/\w\:/.test(startPath)) {
                // handle file:///C:/ paths
                protocol += '/';
                return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, '/');
              }
              return protocol + path.resolve(dir.slice(protocol.length), url);
            }

            function retrieveSourceMapURL(source) {
              var fileData;

              if (isInBrowser()) {
                 try {
                   var xhr = new XMLHttpRequest();
                   xhr.open('GET', source, false);
                   xhr.send(null);
                   fileData = xhr.readyState === 4 ? xhr.responseText : null;

                   // Support providing a sourceMappingURL via the SourceMap header
                   var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
                                         xhr.getResponseHeader("X-SourceMap");
                   if (sourceMapHeader) {
                     return sourceMapHeader;
                   }
                 } catch (e) {
                 }
              }

              // Get the URL of the source map
              fileData = retrieveFile(source);
              var re = /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^\*]+?)[ \t]*(?:\*\/)[ \t]*$)/mg;
              // Keep executing the search to find the *last* sourceMappingURL to avoid
              // picking up sourceMappingURLs from comments, strings, etc.
              var lastMatch, match;
              while (match = re.exec(fileData)) lastMatch = match;
              if (!lastMatch) return null;
              return lastMatch[1];
            }
            // Can be overridden by the retrieveSourceMap option to install. Takes a
            // generated source filename; returns a {map, optional url} object, or null if
            // there is no source map.  The map field may be either a string or the parsed
            // JSON object (ie, it must be a valid argument to the SourceMapConsumer
            // constructor).
            var retrieveSourceMap = handlerExec(retrieveMapHandlers);
            retrieveMapHandlers.push(function(source) {
              var sourceMappingURL = retrieveSourceMapURL(source);
              if (!sourceMappingURL) return null;

              // Read the contents of the source map
              var sourceMapData;
              if (reSourceMap.test(sourceMappingURL)) {
                // Support source map URL as a data url
                var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
                sourceMapData = bufferFrom_1(rawData, "base64").toString();
                sourceMappingURL = source;
              } else {
                // Support source map URLs relative to the source URL
                sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
                sourceMapData = retrieveFile(sourceMappingURL);
              }

              if (!sourceMapData) {
                return null;
              }

              return {
                url: sourceMappingURL,
                map: sourceMapData
              };
            });

            function mapSourcePosition(position) {
              var sourceMap = sourceMapCache[position.source];
              if (!sourceMap) {
                // Call the (overrideable) retrieveSourceMap function to get the source map.
                var urlAndMap = retrieveSourceMap(position.source);
                if (urlAndMap) {
                  sourceMap = sourceMapCache[position.source] = {
                    url: urlAndMap.url,
                    map: new SourceMapConsumer$2(urlAndMap.map)
                  };

                  // Load all sources stored inline with the source map into the file cache
                  // to pretend like they are already loaded. They may not exist on disk.
                  if (sourceMap.map.sourcesContent) {
                    sourceMap.map.sources.forEach(function(source, i) {
                      var contents = sourceMap.map.sourcesContent[i];
                      if (contents) {
                        var url = supportRelativeURL(sourceMap.url, source);
                        fileContentsCache[url] = contents;
                      }
                    });
                  }
                } else {
                  sourceMap = sourceMapCache[position.source] = {
                    url: null,
                    map: null
                  };
                }
              }

              // Resolve the source URL relative to the URL of the source map
              if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === 'function') {
                var originalPosition = sourceMap.map.originalPositionFor(position);

                // Only return the original position if a matching line was found. If no
                // matching line is found then we return position instead, which will cause
                // the stack trace to print the path and line for the compiled file. It is
                // better to give a precise location in the compiled file than a vague
                // location in the original file.
                if (originalPosition.source !== null) {
                  originalPosition.source = supportRelativeURL(
                    sourceMap.url, originalPosition.source);
                  return originalPosition;
                }
              }

              return position;
            }

            // Parses code generated by FormatEvalOrigin(), a function inside V8:
            // https://code.google.com/p/v8/source/browse/trunk/src/messages.js
            function mapEvalOrigin(origin) {
              // Most eval() calls are in this format
              var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
              if (match) {
                var position = mapSourcePosition({
                  source: match[2],
                  line: +match[3],
                  column: match[4] - 1
                });
                return 'eval at ' + match[1] + ' (' + position.source + ':' +
                  position.line + ':' + (position.column + 1) + ')';
              }

              // Parse nested eval() calls using recursion
              match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
              if (match) {
                return 'eval at ' + match[1] + ' (' + mapEvalOrigin(match[2]) + ')';
              }

              // Make sure we still return useful information if we didn't find anything
              return origin;
            }

            // This is copied almost verbatim from the V8 source code at
            // https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
            // implementation of wrapCallSite() used to just forward to the actual source
            // code of CallSite.prototype.toString but unfortunately a new release of V8
            // did something to the prototype chain and broke the shim. The only fix I
            // could find was copy/paste.
            function CallSiteToString() {
              var fileName;
              var fileLocation = "";
              if (this.isNative()) {
                fileLocation = "native";
              } else {
                fileName = this.getScriptNameOrSourceURL();
                if (!fileName && this.isEval()) {
                  fileLocation = this.getEvalOrigin();
                  fileLocation += ", ";  // Expecting source position to follow.
                }

                if (fileName) {
                  fileLocation += fileName;
                } else {
                  // Source code does not originate from a file and is not native, but we
                  // can still get the source position inside the source string, e.g. in
                  // an eval string.
                  fileLocation += "<anonymous>";
                }
                var lineNumber = this.getLineNumber();
                if (lineNumber != null) {
                  fileLocation += ":" + lineNumber;
                  var columnNumber = this.getColumnNumber();
                  if (columnNumber) {
                    fileLocation += ":" + columnNumber;
                  }
                }
              }

              var line = "";
              var functionName = this.getFunctionName();
              var addSuffix = true;
              var isConstructor = this.isConstructor();
              var isMethodCall = !(this.isToplevel() || isConstructor);
              if (isMethodCall) {
                var typeName = this.getTypeName();
                // Fixes shim to be backward compatable with Node v0 to v4
                if (typeName === "[object Object]") {
                  typeName = "null";
                }
                var methodName = this.getMethodName();
                if (functionName) {
                  if (typeName && functionName.indexOf(typeName) != 0) {
                    line += typeName + ".";
                  }
                  line += functionName;
                  if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
                    line += " [as " + methodName + "]";
                  }
                } else {
                  line += typeName + "." + (methodName || "<anonymous>");
                }
              } else if (isConstructor) {
                line += "new " + (functionName || "<anonymous>");
              } else if (functionName) {
                line += functionName;
              } else {
                line += fileLocation;
                addSuffix = false;
              }
              if (addSuffix) {
                line += " (" + fileLocation + ")";
              }
              return line;
            }

            function cloneCallSite(frame) {
              var object = {};
              Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
                object[name] = /^(?:is|get)/.test(name) ? function() { return frame[name].call(frame); } : frame[name];
              });
              object.toString = CallSiteToString;
              return object;
            }

            function wrapCallSite(frame) {
              if(frame.isNative()) {
                return frame;
              }

              // Most call sites will return the source file from getFileName(), but code
              // passed to eval() ending in "//# sourceURL=..." will return the source file
              // from getScriptNameOrSourceURL() instead
              var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
              if (source) {
                var line = frame.getLineNumber();
                var column = frame.getColumnNumber() - 1;

                // Fix position in Node where some (internal) code is prepended.
                // See https://github.com/evanw/node-source-map-support/issues/36
                var headerLength = 62;
                if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
                  column -= headerLength;
                }

                var position = mapSourcePosition({
                  source: source,
                  line: line,
                  column: column
                });
                frame = cloneCallSite(frame);
                var originalFunctionName = frame.getFunctionName;
                frame.getFunctionName = function() { return position.name || originalFunctionName(); };
                frame.getFileName = function() { return position.source; };
                frame.getLineNumber = function() { return position.line; };
                frame.getColumnNumber = function() { return position.column + 1; };
                frame.getScriptNameOrSourceURL = function() { return position.source; };
                return frame;
              }

              // Code called using eval() needs special handling
              var origin = frame.isEval() && frame.getEvalOrigin();
              if (origin) {
                origin = mapEvalOrigin(origin);
                frame = cloneCallSite(frame);
                frame.getEvalOrigin = function() { return origin; };
                return frame;
              }

              // If we get here then we were unable to change the source position
              return frame;
            }

            // This function is part of the V8 stack trace API, for more info see:
            // http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
            function prepareStackTrace(error, stack) {
              if (emptyCacheBetweenOperations) {
                fileContentsCache = {};
                sourceMapCache = {};
              }

              return error + stack.map(function(frame) {
                return '\n    at ' + wrapCallSite(frame);
              }).join('');
            }

            // Generate position and snippet of original source with pointer
            function getErrorSource(error) {
              var match = /\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
              if (match) {
                var source = match[1];
                var line = +match[2];
                var column = +match[3];

                // Support the inline sourceContents inside the source map
                var contents = fileContentsCache[source];

                // Support files on disk
                if (!contents && fs && fs.existsSync(source)) {
                  try {
                    contents = fs.readFileSync(source, 'utf8');
                  } catch (er) {
                    contents = '';
                  }
                }

                // Format the line from the original source code like node does
                if (contents) {
                  var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
                  if (code) {
                    return source + ':' + line + '\n' + code + '\n' +
                      new Array(column).join(' ') + '^';
                  }
                }
              }
              return null;
            }

            function printErrorAndExit (error) {
              var source = getErrorSource(error);

              // Ensure error is printed synchronously and not truncated
              if (process.stderr._handle && process.stderr._handle.setBlocking) {
                process.stderr._handle.setBlocking(true);
              }

              if (source) {
                console.error();
                console.error(source);
              }

              console.error(error.stack);
              process.exit(1);
            }

            function shimEmitUncaughtException () {
              var origEmit = process.emit;

              process.emit = function (type) {
                if (type === 'uncaughtException') {
                  var hasStack = (arguments[1] && arguments[1].stack);
                  var hasListeners = (this.listeners(type).length > 0);

                  if (hasStack && !hasListeners) {
                    return printErrorAndExit(arguments[1]);
                  }
                }

                return origEmit.apply(this, arguments);
              };
            }

            var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
            var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);

            var wrapCallSite_1 = wrapCallSite;
            var getErrorSource_1 = getErrorSource;
            var mapSourcePosition_1 = mapSourcePosition;
            var retrieveSourceMap_1 = retrieveSourceMap;

            var install = function(options) {
              options = options || {};

              if (options.environment) {
                environment = options.environment;
                if (["node", "browser", "auto"].indexOf(environment) === -1) {
                  throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}")
                }
              }

              // Allow sources to be found by methods other than reading the files
              // directly from disk.
              if (options.retrieveFile) {
                if (options.overrideRetrieveFile) {
                  retrieveFileHandlers.length = 0;
                }

                retrieveFileHandlers.unshift(options.retrieveFile);
              }

              // Allow source maps to be found by methods other than reading the files
              // directly from disk.
              if (options.retrieveSourceMap) {
                if (options.overrideRetrieveSourceMap) {
                  retrieveMapHandlers.length = 0;
                }

                retrieveMapHandlers.unshift(options.retrieveSourceMap);
              }

              // Support runtime transpilers that include inline source maps
              if (options.hookRequire && !isInBrowser()) {
                var Module;
                try {
                  Module = require$$3;
                } catch (err) {
                  // NOP: Loading in catch block to convert webpack error to warning.
                }
                var $compile = Module.prototype._compile;

                if (!$compile.__sourceMapSupport) {
                  Module.prototype._compile = function(content, filename) {
                    fileContentsCache[filename] = content;
                    sourceMapCache[filename] = undefined;
                    return $compile.call(this, content, filename);
                  };

                  Module.prototype._compile.__sourceMapSupport = true;
                }
              }

              // Configure options
              if (!emptyCacheBetweenOperations) {
                emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
                  options.emptyCacheBetweenOperations : false;
              }

              // Install the error reformatter
              if (!errorFormatterInstalled) {
                errorFormatterInstalled = true;
                Error.prepareStackTrace = prepareStackTrace;
              }

              if (!uncaughtShimInstalled) {
                var installHandler = 'handleUncaughtExceptions' in options ?
                  options.handleUncaughtExceptions : true;

                // Provide the option to not install the uncaught exception handler. This is
                // to support other uncaught exception handlers (in test frameworks, for
                // example). If this handler is not installed and there are no other uncaught
                // exception handlers, uncaught exceptions will be caught by node's built-in
                // exception handler and the process will still be terminated. However, the
                // generated JavaScript code will be shown above the stack trace instead of
                // the original source code.
                if (installHandler && hasGlobalProcessEventEmitter()) {
                  uncaughtShimInstalled = true;
                  shimEmitUncaughtException();
                }
              }
            };

            var resetRetrieveHandlers = function() {
              retrieveFileHandlers.length = 0;
              retrieveMapHandlers.length = 0;

              retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
              retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
            };

            var sourceMapSupport = {
            	wrapCallSite: wrapCallSite_1,
            	getErrorSource: getErrorSource_1,
            	mapSourcePosition: mapSourcePosition_1,
            	retrieveSourceMap: retrieveSourceMap_1,
            	install: install,
            	resetRetrieveHandlers: resetRetrieveHandlers
            };

            var typescript = createCommonjsModule(function (module) {
            var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
                __assign = Object.assign || function(t) {
                    for (var s, i = 1, n = arguments.length; i < n; i++) {
                        s = arguments[i];
                        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                            t[p] = s[p];
                    }
                    return t;
                };
                return __assign.apply(this, arguments);
            };
            var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
                return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
                function verb(n) { return function (v) { return step([n, v]); }; }
                function step(op) {
                    if (f) throw new TypeError("Generator is already executing.");
                    while (_) try {
                        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                        if (y = 0, t) op = [op[0] & 2, t.value];
                        switch (op[0]) {
                            case 0: case 1: t = op; break;
                            case 4: _.label++; return { value: op[1], done: false };
                            case 5: _.label++; y = op[1]; op = [0]; continue;
                            case 7: op = _.ops.pop(); _.trys.pop(); continue;
                            default:
                                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                                if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                                if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                                if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                                if (t[2]) _.ops.pop();
                                _.trys.pop(); continue;
                        }
                        op = body.call(thisArg, _);
                    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
                    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
                }
            };
            var __makeTemplateObject = (commonjsGlobal && commonjsGlobal.__makeTemplateObject) || function (cooked, raw) {
                if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
                return cooked;
            };
            var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
                var extendStatics = function (d, b) {
                    extendStatics = Object.setPrototypeOf ||
                        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
                    return extendStatics(d, b);
                };
                return function (d, b) {
                    extendStatics(d, b);
                    function __() { this.constructor = d; }
                    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
                };
            })();
            var ts;
            (function (ts) {
                // WARNING: The script `configureNightly.ts` uses a regexp to parse out these values.
                // If changing the text in this section, be sure to test `configureNightly` too.
                ts.versionMajorMinor = "3.4";
                /** The version of the TypeScript compiler release */
                ts.version = ts.versionMajorMinor + ".1";
            })(ts || (ts = {}));
            (function (ts) {
                /* @internal */
                var Comparison;
                (function (Comparison) {
                    Comparison[Comparison["LessThan"] = -1] = "LessThan";
                    Comparison[Comparison["EqualTo"] = 0] = "EqualTo";
                    Comparison[Comparison["GreaterThan"] = 1] = "GreaterThan";
                })(Comparison = ts.Comparison || (ts.Comparison = {}));
            })(ts || (ts = {}));
            /* @internal */
            (function (ts) {
                ts.emptyArray = [];
                /** Create a MapLike with good performance. */
                function createDictionaryObject() {
                    var map = Object.create(/*prototype*/ null); // tslint:disable-line:no-null-keyword
                    // Using 'delete' on an object causes V8 to put the object in dictionary mode.
                    // This disables creation of hidden classes, which are expensive when an object is
                    // constantly changing shape.
                    map.__ = undefined;
                    delete map.__;
                    return map;
                }
                /** Create a new map. If a template object is provided, the map will copy entries from it. */
                function createMap() {
                    return new ts.MapCtr();
                }
                ts.createMap = createMap;
                function createMapFromEntries(entries) {
                    var map = createMap();
                    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
                        var _a = entries_1[_i], key = _a[0], value = _a[1];
                        map.set(key, value);
                    }
                    return map;
                }
                ts.createMapFromEntries = createMapFromEntries;
                function createMapFromTemplate(template) {
                    var map = new ts.MapCtr();
                    // Copies keys/values from template. Note that for..in will not throw if
                    // template is undefined, and instead will just exit the loop.
                    for (var key in template) {
                        if (hasOwnProperty.call(template, key)) {
                            map.set(key, template[key]);
                        }
                    }
                    return map;
                }
                ts.createMapFromTemplate = createMapFromTemplate;
                // Internet Explorer's Map doesn't support iteration, so don't use it.
                // tslint:disable-next-line no-in-operator variable-name
                ts.MapCtr = typeof Map !== "undefined" && "entries" in Map.prototype ? Map : shimMap();
                // Keep the class inside a function so it doesn't get compiled if it's not used.
                function shimMap() {
                    var MapIterator = /** @class */ (function () {
                        function MapIterator(currentEntry, selector) {
                            this.currentEntry = currentEntry;
                            this.selector = selector;
                        }
                        MapIterator.prototype.next = function () {
                            // Navigate to the next entry.
                            while (this.currentEntry) {
                                var skipNext = !!this.currentEntry.skipNext;
                                this.currentEntry = this.currentEntry.nextEntry;
                                if (!skipNext) {
                                    break;
                                }
                            }
                            if (this.currentEntry) {
                                return { value: this.selector(this.currentEntry.key, this.currentEntry.value), done: false };
                            }
                            else {
                                return { value: undefined, done: true };
                            }
                        };
                        return MapIterator;
                    }());
                    return /** @class */ (function () {
                        function class_1() {
                            this.data = createDictionaryObject();
                            this.size = 0;
                            // Create a first (stub) map entry that will not contain a key
                            // and value but serves as starting point for iterators.
                            this.firstEntry = {};
                            // When the map is empty, the last entry is the same as the
                            // first one.
                            this.lastEntry = this.firstEntry;
                        }
                        class_1.prototype.get = function (key) {
                            var entry = this.data[key];
                            return entry && entry.value;
                        };
                        class_1.prototype.set = function (key, value) {
                            if (!this.has(key)) {
                                this.size++;
                                // Create a new entry that will be appended at the
                                // end of the linked list.
                                var newEntry = {
                                    key: key,
                                    value: value
                                };
                                this.data[key] = newEntry;
                                // Adjust the references.
                                var previousLastEntry = this.lastEntry;
                                previousLastEntry.nextEntry = newEntry;
                                newEntry.previousEntry = previousLastEntry;
                                this.lastEntry = newEntry;
                            }
                            else {
                                this.data[key].value = value;
                            }
                            return this;
                        };
                        class_1.prototype.has = function (key) {
                            // tslint:disable-next-line:no-in-operator
                            return key in this.data;
                        };
                        class_1.prototype.delete = function (key) {
                            if (this.has(key)) {
                                this.size--;
                                var entry = this.data[key];
                                delete this.data[key];
                                // Adjust the linked list references of the neighbor entries.
                                var previousEntry = entry.previousEntry;
                                previousEntry.nextEntry = entry.nextEntry;
                                if (entry.nextEntry) {
                                    entry.nextEntry.previousEntry = previousEntry;
                                }
                                // When the deleted entry was the last one, we need to
                                // adust the lastEntry reference.
                                if (this.lastEntry === entry) {
                                    this.lastEntry = previousEntry;
                                }
                                // Adjust the forward reference of the deleted entry
                                // in case an iterator still references it. This allows us
                                // to throw away the entry, but when an active iterator
                                // (which points to the current entry) continues, it will
                                // navigate to the entry that originally came before the
                                // current one and skip it.
                                entry.previousEntry = undefined;
                                entry.nextEntry = previousEntry;
                                entry.skipNext = true;
                                return true;
                            }
                            return false;
                        };
                        class_1.prototype.clear = function () {
                            this.data = createDictionaryObject();
                            this.size = 0;
                            // Reset the linked list. Note that we must adjust the forward
                            // references of the deleted entries to ensure iterators stuck
                            // in the middle of the list don't continue with deleted entries,
                            // but can continue with new entries added after the clear()
                            // operation.
                            var firstEntry = this.firstEntry;
                            var currentEntry = firstEntry.nextEntry;
                            while (currentEntry) {
                                var nextEntry = currentEntry.nextEntry;
                                currentEntry.previousEntry = undefined;
                                currentEntry.nextEntry = firstEntry;
                                currentEntry.skipNext = true;
                                currentEntry = nextEntry;
                            }
                            firstEntry.nextEntry = undefined;
                            this.lastEntry = firstEntry;
                        };
                        class_1.prototype.keys = function () {
                            return new MapIterator(this.firstEntry, function (key) { return key; });
                        };
                        class_1.prototype.values = function () {
                            return new MapIterator(this.firstEntry, function (_key, value) { return value; });
                        };
                        class_1.prototype.entries = function () {
                            return new MapIterator(this.firstEntry, function (key, value) { return [key, value]; });
                        };
                        class_1.prototype.forEach = function (action) {
                            var iterator = this.entries();
                            while (true) {
                                var _a = iterator.next(), entry = _a.value, done = _a.done;
                                if (done) {
                                    break;
                                }
                                action(entry[1], entry[0]);
                            }
                        };
                        return class_1;
                    }());
                }
                ts.shimMap = shimMap;
                function length(array) {
                    return array ? array.length : 0;
                }
                ts.length = length;
                /**
                 * Iterates through 'array' by index and performs the callback on each element of array until the callback
                 * returns a truthy value, then returns that value.
                 * If no such value is found, the callback is applied to each element of array and undefined is returned.
                 */
                function forEach(array, callback) {
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var result = callback(array[i], i);
                            if (result) {
                                return result;
                            }
                        }
                    }
                    return undefined;
                }
                ts.forEach = forEach;
                /** Like `forEach`, but suitable for use with numbers and strings (which may be falsy). */
                function firstDefined(array, callback) {
                    if (array === undefined) {
                        return undefined;
                    }
                    for (var i = 0; i < array.length; i++) {
                        var result = callback(array[i], i);
                        if (result !== undefined) {
                            return result;
                        }
                    }
                    return undefined;
                }
                ts.firstDefined = firstDefined;
                function firstDefinedIterator(iter, callback) {
                    while (true) {
                        var _a = iter.next(), value = _a.value, done = _a.done;
                        if (done) {
                            return undefined;
                        }
                        var result = callback(value);
                        if (result !== undefined) {
                            return result;
                        }
                    }
                }
                ts.firstDefinedIterator = firstDefinedIterator;
                function zipWith(arrayA, arrayB, callback) {
                    var result = [];
                    Debug.assertEqual(arrayA.length, arrayB.length);
                    for (var i = 0; i < arrayA.length; i++) {
                        result.push(callback(arrayA[i], arrayB[i], i));
                    }
                    return result;
                }
                ts.zipWith = zipWith;
                function zipToIterator(arrayA, arrayB) {
                    Debug.assertEqual(arrayA.length, arrayB.length);
                    var i = 0;
                    return {
                        next: function () {
                            if (i === arrayA.length) {
                                return { value: undefined, done: true };
                            }
                            i++;
                            return { value: [arrayA[i - 1], arrayB[i - 1]], done: false };
                        }
                    };
                }
                ts.zipToIterator = zipToIterator;
                function zipToMap(keys, values) {
                    Debug.assert(keys.length === values.length);
                    var map = createMap();
                    for (var i = 0; i < keys.length; ++i) {
                        map.set(keys[i], values[i]);
                    }
                    return map;
                }
                ts.zipToMap = zipToMap;
                /**
                 * Iterates through `array` by index and performs the callback on each element of array until the callback
                 * returns a falsey value, then returns false.
                 * If no such value is found, the callback is applied to each element of array and `true` is returned.
                 */
                function every(array, callback) {
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            if (!callback(array[i], i)) {
                                return false;
                            }
                        }
                    }
                    return true;
                }
                ts.every = every;
                function find(array, predicate) {
                    for (var i = 0; i < array.length; i++) {
                        var value = array[i];
                        if (predicate(value, i)) {
                            return value;
                        }
                    }
                    return undefined;
                }
                ts.find = find;
                function findLast(array, predicate) {
                    for (var i = array.length - 1; i >= 0; i--) {
                        var value = array[i];
                        if (predicate(value, i)) {
                            return value;
                        }
                    }
                    return undefined;
                }
                ts.findLast = findLast;
                /** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
                function findIndex(array, predicate, startIndex) {
                    for (var i = startIndex || 0; i < array.length; i++) {
                        if (predicate(array[i], i)) {
                            return i;
                        }
                    }
                    return -1;
                }
                ts.findIndex = findIndex;
                function findLastIndex(array, predicate, startIndex) {
                    for (var i = startIndex === undefined ? array.length - 1 : startIndex; i >= 0; i--) {
                        if (predicate(array[i], i)) {
                            return i;
                        }
                    }
                    return -1;
                }
                ts.findLastIndex = findLastIndex;
                /**
                 * Returns the first truthy result of `callback`, or else fails.
                 * This is like `forEach`, but never returns undefined.
                 */
                function findMap(array, callback) {
                    for (var i = 0; i < array.length; i++) {
                        var result = callback(array[i], i);
                        if (result) {
                            return result;
                        }
                    }
                    return Debug.fail();
                }
                ts.findMap = findMap;
                function contains(array, value, equalityComparer) {
                    if (equalityComparer === void 0) { equalityComparer = equateValues; }
                    if (array) {
                        for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
                            var v = array_1[_i];
                            if (equalityComparer(v, value)) {
                                return true;
                            }
                        }
                    }
                    return false;
                }
                ts.contains = contains;
                function arraysEqual(a, b, equalityComparer) {
                    if (equalityComparer === void 0) { equalityComparer = equateValues; }
                    return a.length === b.length && a.every(function (x, i) { return equalityComparer(x, b[i]); });
                }
                ts.arraysEqual = arraysEqual;
                function indexOfAnyCharCode(text, charCodes, start) {
                    for (var i = start || 0; i < text.length; i++) {
                        if (contains(charCodes, text.charCodeAt(i))) {
                            return i;
                        }
                    }
                    return -1;
                }
                ts.indexOfAnyCharCode = indexOfAnyCharCode;
                function countWhere(array, predicate) {
                    var count = 0;
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var v = array[i];
                            if (predicate(v, i)) {
                                count++;
                            }
                        }
                    }
                    return count;
                }
                ts.countWhere = countWhere;
                function filter(array, f) {
                    if (array) {
                        var len = array.length;
                        var i = 0;
                        while (i < len && f(array[i]))
                            i++;
                        if (i < len) {
                            var result = array.slice(0, i);
                            i++;
                            while (i < len) {
                                var item = array[i];
                                if (f(item)) {
                                    result.push(item);
                                }
                                i++;
                            }
                            return result;
                        }
                    }
                    return array;
                }
                ts.filter = filter;
                function filterMutate(array, f) {
                    var outIndex = 0;
                    for (var i = 0; i < array.length; i++) {
                        if (f(array[i], i, array)) {
                            array[outIndex] = array[i];
                            outIndex++;
                        }
                    }
                    array.length = outIndex;
                }
                ts.filterMutate = filterMutate;
                function clear(array) {
                    array.length = 0;
                }
                ts.clear = clear;
                function map(array, f) {
                    var result;
                    if (array) {
                        result = [];
                        for (var i = 0; i < array.length; i++) {
                            result.push(f(array[i], i));
                        }
                    }
                    return result;
                }
                ts.map = map;
                function mapIterator(iter, mapFn) {
                    return {
                        next: function () {
                            var iterRes = iter.next();
                            return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false };
                        }
                    };
                }
                ts.mapIterator = mapIterator;
                function sameMap(array, f) {
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var item = array[i];
                            var mapped = f(item, i);
                            if (item !== mapped) {
                                var result = array.slice(0, i);
                                result.push(mapped);
                                for (i++; i < array.length; i++) {
                                    result.push(f(array[i], i));
                                }
                                return result;
                            }
                        }
                    }
                    return array;
                }
                ts.sameMap = sameMap;
                function flatten(array) {
                    var result;
                    if (array) {
                        result = [];
                        for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
                            var v = array_2[_i];
                            if (v) {
                                if (isArray(v)) {
                                    addRange(result, v);
                                }
                                else {
                                    result.push(v);
                                }
                            }
                        }
                    }
                    return result;
                }
                ts.flatten = flatten;
                /**
                 * Maps an array. If the mapped value is an array, it is spread into the result.
                 *
                 * @param array The array to map.
                 * @param mapfn The callback used to map the result into one or more values.
                 */
                function flatMap(array, mapfn) {
                    var result;
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var v = mapfn(array[i], i);
                            if (v) {
                                if (isArray(v)) {
                                    result = addRange(result, v);
                                }
                                else {
                                    result = append(result, v);
                                }
                            }
                        }
                    }
                    return result || ts.emptyArray;
                }
                ts.flatMap = flatMap;
                function flatMapToMutable(array, mapfn) {
                    var result = [];
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var v = mapfn(array[i], i);
                            if (v) {
                                if (isArray(v)) {
                                    addRange(result, v);
                                }
                                else {
                                    result.push(v);
                                }
                            }
                        }
                    }
                    return result;
                }
                ts.flatMapToMutable = flatMapToMutable;
                function flatMapIterator(iter, mapfn) {
                    var first = iter.next();
                    if (first.done) {
                        return ts.emptyIterator;
                    }
                    var currentIter = getIterator(first.value);
                    return {
                        next: function () {
                            while (true) {
                                var currentRes = currentIter.next();
                                if (!currentRes.done) {
                                    return currentRes;
                                }
                                var iterRes = iter.next();
                                if (iterRes.done) {
                                    return iterRes;
                                }
                                currentIter = getIterator(iterRes.value);
                            }
                        },
                    };
                    function getIterator(x) {
                        var res = mapfn(x);
                        return res === undefined ? ts.emptyIterator : isArray(res) ? arrayIterator(res) : res;
                    }
                }
                ts.flatMapIterator = flatMapIterator;
                function sameFlatMap(array, mapfn) {
                    var result;
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var item = array[i];
                            var mapped = mapfn(item, i);
                            if (result || item !== mapped || isArray(mapped)) {
                                if (!result) {
                                    result = array.slice(0, i);
                                }
                                if (isArray(mapped)) {
                                    addRange(result, mapped);
                                }
                                else {
                                    result.push(mapped);
                                }
                            }
                        }
                    }
                    return result || array;
                }
                ts.sameFlatMap = sameFlatMap;
                function mapAllOrFail(array, mapFn) {
                    var result = [];
                    for (var i = 0; i < array.length; i++) {
                        var mapped = mapFn(array[i], i);
                        if (mapped === undefined) {
                            return undefined;
                        }
                        result.push(mapped);
                    }
                    return result;
                }
                ts.mapAllOrFail = mapAllOrFail;
                function mapDefined(array, mapFn) {
                    var result = [];
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var mapped = mapFn(array[i], i);
                            if (mapped !== undefined) {
                                result.push(mapped);
                            }
                        }
                    }
                    return result;
                }
                ts.mapDefined = mapDefined;
                function mapDefinedIterator(iter, mapFn) {
                    return {
                        next: function () {
                            while (true) {
                                var res = iter.next();
                                if (res.done) {
                                    return res;
                                }
                                var value = mapFn(res.value);
                                if (value !== undefined) {
                                    return { value: value, done: false };
                                }
                            }
                        }
                    };
                }
                ts.mapDefinedIterator = mapDefinedIterator;
                ts.emptyIterator = { next: function () { return ({ value: undefined, done: true }); } };
                function singleIterator(value) {
                    var done = false;
                    return {
                        next: function () {
                            var wasDone = done;
                            done = true;
                            return wasDone ? { value: undefined, done: true } : { value: value, done: false };
                        }
                    };
                }
                ts.singleIterator = singleIterator;
                function spanMap(array, keyfn, mapfn) {
                    var result;
                    if (array) {
                        result = [];
                        var len = array.length;
                        var previousKey = void 0;
                        var key = void 0;
                        var start = 0;
                        var pos = 0;
                        while (start < len) {
                            while (pos < len) {
                                var value = array[pos];
                                key = keyfn(value, pos);
                                if (pos === 0) {
                                    previousKey = key;
                                }
                                else if (key !== previousKey) {
                                    break;
                                }
                                pos++;
                            }
                            if (start < pos) {
                                var v = mapfn(array.slice(start, pos), previousKey, start, pos);
                                if (v) {
                                    result.push(v);
                                }
                                start = pos;
                            }
                            previousKey = key;
                            pos++;
                        }
                    }
                    return result;
                }
                ts.spanMap = spanMap;
                function mapEntries(map, f) {
                    if (!map) {
                        return undefined;
                    }
                    var result = createMap();
                    map.forEach(function (value, key) {
                        var _a = f(key, value), newKey = _a[0], newValue = _a[1];
                        result.set(newKey, newValue);
                    });
                    return result;
                }
                ts.mapEntries = mapEntries;
                function some(array, predicate) {
                    if (array) {
                        if (predicate) {
                            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
                                var v = array_3[_i];
                                if (predicate(v)) {
                                    return true;
                                }
                            }
                        }
                        else {
                            return array.length > 0;
                        }
                    }
                    return false;
                }
                ts.some = some;
                /** Calls the callback with (start, afterEnd) index pairs for each range where 'pred' is true. */
                function getRangesWhere(arr, pred, cb) {
                    var start;
                    for (var i = 0; i < arr.length; i++) {
                        if (pred(arr[i])) {
                            start = start === undefined ? i : start;
                        }
                        else {
                            if (start !== undefined) {
                                cb(start, i);
                                start = undefined;
                            }
                        }
                    }
                    if (start !== undefined)
                        cb(start, arr.length);
                }
                ts.getRangesWhere = getRangesWhere;
                function concatenate(array1, array2) {
                    if (!some(array2))
                        return array1;
                    if (!some(array1))
                        return array2;
                    return array1.concat(array2);
                }
                ts.concatenate = concatenate;
                function deduplicateRelational(array, equalityComparer, comparer) {
                    // Perform a stable sort of the array. This ensures the first entry in a list of
                    // duplicates remains the first entry in the result.
                    var indices = array.map(function (_, i) { return i; });
                    stableSortIndices(array, indices, comparer);
                    var last = array[indices[0]];
                    var deduplicated = [indices[0]];
                    for (var i = 1; i < indices.length; i++) {
                        var index = indices[i];
                        var item = array[index];
                        if (!equalityComparer(last, item)) {
                            deduplicated.push(index);
                            last = item;
                        }
                    }
                    // restore original order
                    deduplicated.sort();
                    return deduplicated.map(function (i) { return array[i]; });
                }
                function deduplicateEquality(array, equalityComparer) {
                    var result = [];
                    for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
                        var item = array_4[_i];
                        pushIfUnique(result, item, equalityComparer);
                    }
                    return result;
                }
                /**
                 * Deduplicates an unsorted array.
                 * @param equalityComparer An `EqualityComparer` used to determine if two values are duplicates.
                 * @param comparer An optional `Comparer` used to sort entries before comparison, though the
                 * result will remain in the original order in `array`.
                 */
                function deduplicate(array, equalityComparer, comparer) {
                    return array.length === 0 ? [] :
                        array.length === 1 ? array.slice() :
                            comparer ? deduplicateRelational(array, equalityComparer, comparer) :
                                deduplicateEquality(array, equalityComparer);
                }
                ts.deduplicate = deduplicate;
                /**
                 * Deduplicates an array that has already been sorted.
                 */
                function deduplicateSorted(array, comparer) {
                    if (array.length === 0)
                        return ts.emptyArray;
                    var last = array[0];
                    var deduplicated = [last];
                    for (var i = 1; i < array.length; i++) {
                        var next = array[i];
                        switch (comparer(next, last)) {
                            // equality comparison
                            case true:
                            // relational comparison
                            case 0 /* EqualTo */:
                                continue;
                            case -1 /* LessThan */:
                                // If `array` is sorted, `next` should **never** be less than `last`.
                                return Debug.fail("Array is unsorted.");
                        }
                        deduplicated.push(last = next);
                    }
                    return deduplicated;
                }
                function insertSorted(array, insert, compare) {
                    if (array.length === 0) {
                        array.push(insert);
                        return;
                    }
                    var insertIndex = binarySearch(array, insert, identity, compare);
                    if (insertIndex < 0) {
                        array.splice(~insertIndex, 0, insert);
                    }
                }
                ts.insertSorted = insertSorted;
                function sortAndDeduplicate(array, comparer, equalityComparer) {
                    return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
                }
                ts.sortAndDeduplicate = sortAndDeduplicate;
                function arrayIsEqualTo(array1, array2, equalityComparer) {
                    if (equalityComparer === void 0) { equalityComparer = equateValues; }
                    if (!array1 || !array2) {
                        return array1 === array2;
                    }
                    if (array1.length !== array2.length) {
                        return false;
                    }
                    for (var i = 0; i < array1.length; i++) {
                        if (!equalityComparer(array1[i], array2[i], i)) {
                            return false;
                        }
                    }
                    return true;
                }
                ts.arrayIsEqualTo = arrayIsEqualTo;
                function compact(array) {
                    var result;
                    if (array) {
                        for (var i = 0; i < array.length; i++) {
                            var v = array[i];
                            if (result || !v) {
                                if (!result) {
                                    result = array.slice(0, i);
                                }
                                if (v) {
                                    result.push(v);
                                }
                            }
                        }
                    }
                    return result || array;
                }
                ts.compact = compact;
                /**
                 * Gets the relative complement of `arrayA` with respect to `arrayB`, returning the elements that
                 * are not present in `arrayA` but are present in `arrayB`. Assumes both arrays are sorted
                 * based on the provided comparer.
                 */
                function relativeComplement(arrayA, arrayB, comparer) {
                    if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)
                        return arrayB;
                    var result = [];
                    loopB: for (var offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
                        if (offsetB > 0) {
                            // Ensure `arrayB` is properly sorted.
                            Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0 /* EqualTo */);
                        }
                        loopA: for (var startA = offsetA; offsetA < arrayA.length; offsetA++) {
                            if (offsetA > startA) {
                                // Ensure `arrayA` is properly sorted. We only need to perform this check if
                                // `offsetA` has changed since we entered the loop.
                                Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0 /* EqualTo */);
                            }
                            switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
                                case -1 /* LessThan */:
                                    // If B is less than A, B does not exist in arrayA. Add B to the result and
                                    // move to the next element in arrayB without changing the current position
                                    // in arrayA.
                                    result.push(arrayB[offsetB]);
                                    continue loopB;
                                case 0 /* EqualTo */:
                                    // If B is equal to A, B exists in arrayA. Move to the next element in
                                    // arrayB without adding B to the result or changing the current position
                                    // in arrayA.
                                    continue loopB;
                                case 1 /* GreaterThan */:
                                    // If B is greater than A, we need to keep looking for B in arrayA. Move to
                                    // the next element in arrayA and recheck.
                                    continue loopA;
                            }
                        }
                    }
                    return result;
                }
                ts.relativeComplement = relativeComplement;
                function sum(array, prop) {
                    var result = 0;
                    for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
                        var v = array_5[_i];
                        result += v[prop];
                    }
                    return result;
                }
                ts.sum = sum;
                function append(to, value) {
                    if (value === undefined)
                        return to;
                    if (to === undefined)
                        return [value];
                    to.push(value);
                    return to;
                }
                ts.append = append;
                /**
                 * Gets the actual offset into an array for a relative offset. Negative offsets indicate a
                 * position offset from the end of the array.
                 */
                function toOffset(array, offset) {
                    return offset < 0 ? array.length + offset : offset;
                }
                function addRange(to, from, start, end) {
                    if (from === undefined || from.length === 0)
                        return to;
                    if (to === undefined)
                        return from.slice(start, end);
                    start = start === undefined ? 0 : toOffset(from, start);
                    end = end === undefined ? from.length : toOffset(from, end);
                    for (var i = start; i < end && i < from.length; i++) {
                        if (from[i] !== undefined) {
                            to.push(from[i]);
                        }
                    }
                    return to;
                }
                ts.addRange = addRange;
                /**
                 * @return Whether the value was added.
                 */
                function pushIfUnique(array, toAdd, equalityComparer) {
                    if (contains(array, toAdd, equalityComparer)) {
                        return false;
                    }
                    else {
                        array.push(toAdd);
                        return true;
                    }
                }
                ts.pushIfUnique = pushIfUnique;
                /**
                 * Unlike `pushIfUnique`, this can take `undefined` as an input, and returns a new array.
                 */
                function appendIfUnique(array, toAdd, equalityComparer) {
                    if (array) {
                        pushIfUnique(array, toAdd, equalityComparer);
                        return array;
                    }
                    else {
                        return [toAdd];
                    }
                }
                ts.appendIfUnique = appendIfUnique;
                function stableSortIndices(array, indices, comparer) {
                    // sort indices by value then position
                    indices.sort(function (x, y) { return comparer(array[x], array[y]) || compareValues(x, y); });
                }
                /**
                 * Returns a new sorted array.
                 */
                function sort(array, comparer) {
                    return (array.length === 0 ? array : array.slice().sort(comparer));
                }
                ts.sort = sort;
                function arrayIterator(array) {
                    var i = 0;
                    return { next: function () {
                            if (i === array.length) {
                                return { value: undefined, done: true };
                            }
                            else {
                                i++;
                                return { value: array[i - 1], done: false };
                            }
                        } };
                }
                ts.arrayIterator = arrayIterator;
                function arrayReverseIterator(array) {
                    var i = array.length;
                    return {
                        next: function () {
                            if (i === 0) {
                                return { value: undefined, done: true };
                            }
                            else {
                                i--;
                                return { value: array[i], done: false };
                            }
                        }
                    };
                }
                ts.arrayReverseIterator = arrayReverseIterator;
                /**
                 * Stable sort of an array. Elements equal to each other maintain their relative position in the array.
                 */
                function stableSort(array, comparer) {
                    var indices = array.map(function (_, i) { return i; });
                    stableSortIndices(array, indices, comparer);
                    return indices.map(function (i) { return array[i]; });
                }
                ts.stableSort = stableSort;
                function rangeEquals(array1, array2, pos, end) {
                    while (pos < end) {
                        if (array1[pos] !== array2[pos]) {
                            return false;
                        }
                        pos++;
                    }
                    return true;
                }
                ts.rangeEquals = rangeEquals;
                /**
                 * Returns the element at a specific offset in an array if non-empty, `undefined` otherwise.
                 * A negative offset indicates the element should be retrieved from the end of the array.
                 */
                function elementAt(array, offset) {
                    if (array) {
                        offset = toOffset(array, offset);
                        if (offset < array.length) {
                            return array[offset];
                        }
                    }
                    return undefined;
                }
                ts.elementAt = elementAt;
                /**
                 * Returns the first element of an array if non-empty, `undefined` otherwise.
                 */
                function firstOrUndefined(array) {
                    return array.length === 0 ? undefined : array[0];
                }
                ts.firstOrUndefined = firstOrUndefined;
                function first(array) {
                    Debug.assert(array.length !== 0);
                    return array[0];
                }
                ts.first = first;
                /**
                 * Returns the last element of an array if non-empty, `undefined` otherwise.
                 */
                function lastOrUndefined(array) {
                    return array.length === 0 ? undefined : array[array.length - 1];
                }
                ts.lastOrUndefined = lastOrUndefined;
                function last(array) {
                    Debug.assert(array.length !== 0);
                    return array[array.length - 1];
                }
                ts.last = last;
                /**
                 * Returns the only element of an array if it contains only one element, `undefined` otherwise.
                 */
                function singleOrUndefined(array) {
                    return array && array.length === 1
                        ? array[0]
                        : undefined;
                }
                ts.singleOrUndefined = singleOrUndefined;
                function singleOrMany(array) {
                    return array && array.length === 1
                        ? array[0]
                        : array;
                }
                ts.singleOrMany = singleOrMany;
                function replaceElement(array, index, value) {
                    var result = array.slice(0);
                    result[index] = value;
                    return result;
                }
                ts.replaceElement = replaceElement;
                /**
                 * Performs a binary search, finding the index at which `value` occurs in `array`.
                 * If no such index is found, returns the 2's-complement of first index at which
                 * `array[index]` exceeds `value`.
                 * @param array A sorted array whose first element must be no larger than number
                 * @param value The value to be searched for in the array.
                 * @param keySelector A callback used to select the search key from `value` and each element of
                 * `array`.
                 * @param keyComparer A callback used to compare two keys in a sorted array.
                 * @param offset An offset into `array` at which to start the search.
                 */
                function binarySearch(array, value, keySelector, keyComparer, offset) {
                    return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset);
                }
                ts.binarySearch = binarySearch;
                /**
                 * Performs a binary search, finding the index at which an object with `key` occurs in `array`.
                 * If no such index is found, returns the 2's-complement of first index at which
                 * `array[index]` exceeds `key`.
                 * @param array A sorted array whose first element must be no larger than number
                 * @param key The key to be searched for in the array.
                 * @param keySelector A callback used to select the search key from each element of `array`.
                 * @param keyComparer A callback used to compare two keys in a sorted array.
                 * @param offset An offset into `array` at which to start the search.
                 */
                function binarySearchKey(array, key, keySelector, keyComparer, offset) {
                    if (!some(array)) {
                        return -1;
                    }
                    var low = offset || 0;
                    var high = array.length - 1;
                    while (low <= high) {
                        var middle = low + ((high - low) >> 1);
                        var midKey = keySelector(array[middle]);
                        switch (keyComparer(midKey, key)) {
                            case -1 /* LessThan */:
                                low = middle + 1;
                                break;
                            case 0 /* EqualTo */:
                                return middle;
                            case 1 /* GreaterThan */:
                                high = middle - 1;
                                break;
                        }
                    }
                    return ~low;
                }
                ts.binarySearchKey = binarySearchKey;
                function reduceLeft(array, f, initial, start, count) {
                    if (array && array.length > 0) {
                        var size = array.length;
                        if (size > 0) {
                            var pos = start === undefined || start < 0 ? 0 : start;
                            var end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count;
                            var result = void 0;
                            if (arguments.length <= 2) {
                                result = array[pos];
                                pos++;
                            }
                            else {
                                result = initial;
                            }
                            while (pos <= end) {
                                result = f(result, array[pos], pos);
                                pos++;
                            }
                            return result;
                        }
                    }
                    return initial;
                }
                ts.reduceLeft = reduceLeft;
                var hasOwnProperty = Object.prototype.hasOwnProperty;
                /**
                 * Indicates whether a map-like contains an own property with the specified key.
                 *
                 * @param map A map-like.
                 * @param key A property key.
                 */
                function hasProperty(map, key) {
                    return hasOwnProperty.call(map, key);
                }
                ts.hasProperty = hasProperty;
                /**
                 * Gets the value of an owned property in a map-like.
                 *
                 * @param map A map-like.
                 * @param key A property key.
                 */
                function getProperty(map, key) {
                    return hasOwnProperty.call(map, key) ? map[key] : undefined;
                }
                ts.getProperty = getProperty;
                /**
                 * Gets the owned, enumerable property keys of a map-like.
                 */
                function getOwnKeys(map) {
                    var keys = [];
                    for (var key in map) {
                        if (hasOwnProperty.call(map, key)) {
                            keys.push(key);
                        }
                    }
                    return keys;
                }
                ts.getOwnKeys = getOwnKeys;
                function getOwnValues(sparseArray) {
                    var values = [];
                    for (var key in sparseArray) {
                        if (hasOwnProperty.call(sparseArray, key)) {
                            values.push(sparseArray[key]);
                        }
                    }
                    return values;
                }
                ts.getOwnValues = getOwnValues;
                function arrayFrom(iterator, map) {
                    var _a;
                    var result = [];
                    for (var _b = iterator.next(), value = _b.value, done = _b.done; !done; _a = iterator.next(), value = _a.value, done = _a.done, _a) {
                        result.push(map ? map(value) : value);
                    }
                    return result;
                }
                ts.arrayFrom = arrayFrom;
                function assign(t) {
                    var args = [];
                    for (var _i = 1; _i < arguments.length; _i++) {
                        args[_i - 1] = arguments[_i];
                    }
                    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
                        var arg = args_1[_a];
                        if (arg === undefined)
                            continue;
                        for (var p in arg) {
                            if (hasProperty(arg, p)) {
                                t[p] = arg[p];
                            }
                        }
                    }
                    return t;
                }
                ts.assign = assign;
                /**
                 * Performs a shallow equality comparison of the contents of two map-likes.
                 *
                 * @param left A map-like whose properties should be compared.
                 * @param right A map-like whose properties should be compared.
                 */
                function equalOwnProperties(left, right, equalityComparer) {
                    if (equalityComparer === void 0) { equalityComparer = equateValues; }
                    if (left === right)
                        return true;
                    if (!left || !right)
                        return false;
                    for (var key in left) {
                        if (hasOwnProperty.call(left, key)) {
                            if (!hasOwnProperty.call(right, key))
                                return false;
                            if (!equalityComparer(left[key], right[key]))
                                return false;
                        }
                    }
                    for (var key in right) {
                        if (hasOwnProperty.call(right, key)) {
                            if (!hasOwnProperty.call(left, key))
                                return false;
                        }
                    }
                    return true;
                }
                ts.equalOwnProperties = equalOwnProperties;
                function arrayToMap(array, makeKey, makeValue) {
                    if (makeValue === void 0) { makeValue = identity; }
                    var result = createMap();
                    for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
                        var value = array_6[_i];
                        var key = makeKey(value);
                        if (key !== undefined)
                            result.set(key, makeValue(value));
                    }
                    return result;
                }
                ts.arrayToMap = arrayToMap;
                function arrayToNumericMap(array, makeKey, makeValue) {
                    if (makeValue === void 0) { makeValue = identity; }
                    var result = [];
                    for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
                        var value = array_7[_i];
                        result[makeKey(value)] = makeValue(value);
                    }
                    return result;
                }
                ts.arrayToNumericMap = arrayToNumericMap;
                function arrayToMultiMap(values, makeKey, makeValue) {
                    if (makeValue === void 0) { makeValue = identity; }
                    var result = createMultiMap();
                    for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
                        var value = values_1[_i];
                        result.add(makeKey(value), makeValue(value));
                    }
                    return result;
                }
                ts.arrayToMultiMap = arrayToMultiMap;
                function group(values, getGroupId) {
                    return arrayFrom(arrayToMultiMap(values, getGroupId).values());
                }
                ts.group = group;
                function clone(object) {
                    var result = {};
                    for (var id in object) {
                        if (hasOwnProperty.call(object, id)) {
                            result[id] = object[id];
                        }
                    }
                    return result;
                }
                ts.clone = clone;
                function extend(first, second) {
                    var result = {};
                    for (var id in second) {
                        if (hasOwnProperty.call(second, id)) {
                            result[id] = second[id];
                        }
                    }
                    for (var id in first) {
                        if (hasOwnProperty.call(first, id)) {
                            result[id] = first[id];
                        }
                    }
                    return result;
                }
                ts.extend = extend;
                function copyProperties(first, second) {
                    for (var id in second) {
                        if (hasOwnProperty.call(second, id)) {
                            first[id] = second[id];
                        }
                    }
                }
                ts.copyProperties = copyProperties;
                function maybeBind(obj, fn) {
                    return fn ? fn.bind(obj) : undefined;
                }
                ts.maybeBind = maybeBind;
                function createMultiMap() {
                    var map = createMap();
                    map.add = multiMapAdd;
                    map.remove = multiMapRemove;
                    return map;
                }
                ts.createMultiMap = createMultiMap;
                function multiMapAdd(key, value) {
                    var values = this.get(key);
                    if (values) {
                        values.push(value);
                    }
                    else {
                        this.set(key, values = [value]);
                    }
                    return values;
                }
                function multiMapRemove(key, value) {
                    var values = this.get(key);
                    if (values) {
                        unorderedRemoveItem(values, value);
                        if (!values.length) {
                            this.delete(key);
                        }
                    }
                }
                /**
                 * Tests whether a value is an array.
                 */
                function isArray(value) {
                    return Array.isArray ? Array.isArray(value) : value instanceof Array;
                }
                ts.isArray = isArray;
                function toArray(value) {
                    return isArray(value) ? value : [value];
                }
                ts.toArray = toArray;
                /**
                 * Tests whether a value is string
                 */
                function isString(text) {
                    return typeof text === "string";
                }
                ts.isString = isString;
                function isNumber(x) {
                    return typeof x === "number";
                }
                ts.isNumber = isNumber;
                function tryCast(value, test) {
                    return value !== undefined && test(value) ? value : undefined;
                }
                ts.tryCast = tryCast;
                function cast(value, test) {
                    if (value !== undefined && test(value))
                        return value;
                    return Debug.fail("Invalid cast. The supplied value " + value + " did not pass the test '" + Debug.getFunctionName(test) + "'.");
                }
                ts.cast = cast;
                /** Does nothing. */
                function noop(_) { } // tslint:disable-line no-empty
                ts.noop = noop;
                /** Do nothing and return false */
                function returnFalse() { return false; }
                ts.returnFalse = returnFalse;
                /** Do nothing and return true */
                function returnTrue() { return true; }
                ts.returnTrue = returnTrue;
                /** Do nothing and return undefined */
                function returnUndefined() { return undefined; }
                ts.returnUndefined = returnUndefined;
                /** Returns its argument. */
                function identity(x) { return x; }
                ts.identity = identity;
                /** Returns lower case string */
                function toLowerCase(x) { return x.toLowerCase(); }
                ts.toLowerCase = toLowerCase;
                /** Throws an error because a function is not implemented. */
                function notImplemented() {
                    throw new Error("Not implemented");
                }
                ts.notImplemented = notImplemented;
                function memoize(callback) {
                    var value;
                    return function () {
                        if (callback) {
                            value = callback();
                            callback = undefined;
                        }
                        return value;
                    };
                }
                ts.memoize = memoize;
                function chain(a, b, c, d, e) {
                    if (e) {
                        var args_2 = [];
                        for (var i = 0; i < arguments.length; i++) {
                            args_2[i] = arguments[i];
                        }
                        return function (t) { return compose.apply(void 0, map(args_2, function (f) { return f(t); })); };
                    }
                    else if (d) {
                        return function (t) { return compose(a(t), b(t), c(t), d(t)); };
                    }
                    else if (c) {
                        return function (t) { return compose(a(t), b(t), c(t)); };
                    }
                    else if (b) {
                        return function (t) { return compose(a(t), b(t)); };
                    }
                    else if (a) {
                        return function (t) { return compose(a(t)); };
                    }
                    else {
                        return function (_) { return function (u) { return u; }; };
                    }
                }
                ts.chain = chain;
                function compose(a, b, c, d, e) {
                    if (e) {
                        var args_3 = [];
                        for (var i = 0; i < arguments.length; i++) {
                            args_3[i] = arguments[i];
                        }
                        return function (t) { return reduceLeft(args_3, function (u, f) { return f(u); }, t); };
                    }
                    else if (d) {
                        return function (t) { return d(c(b(a(t)))); };
                    }
                    else if (c) {
                        return function (t) { return c(b(a(t))); };
                    }
                    else if (b) {
                        return function (t) { return b(a(t)); };
                    }
                    else if (a) {
                        return function (t) { return a(t); };
                    }
                    else {
                        return function (t) { return t; };
                    }
                }
                ts.compose = compose;
                var AssertionLevel;
                (function (AssertionLevel) {
                    AssertionLevel[AssertionLevel["None"] = 0] = "None";
                    AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal";
                    AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive";
                    AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive";
                })(AssertionLevel = ts.AssertionLevel || (ts.AssertionLevel = {}));
                var Debug;
                (function (Debug) {
                    Debug.currentAssertionLevel = 0 /* None */;
                    Debug.isDebugging = false;
                    function shouldAssert(level) {
                        return Debug.currentAssertionLevel >= level;
                    }
                    Debug.shouldAssert = shouldAssert;
                    function assert(expression, message, verboseDebugInfo, stackCrawlMark) {
                        if (!expression) {
                            if (verboseDebugInfo) {
                                message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
                            }
                            fail(message ? "False expression: " + message : "False expression.", stackCrawlMark || assert);
                        }
                    }
                    Debug.assert = assert;
                    function assertEqual(a, b, msg, msg2) {
                        if (a !== b) {
                            var message = msg ? msg2 ? msg + " " + msg2 : msg : "";
                            fail("Expected " + a + " === " + b + ". " + message);
                        }
                    }
                    Debug.assertEqual = assertEqual;
                    function assertLessThan(a, b, msg) {
                        if (a >= b) {
                            fail("Expected " + a + " < " + b + ". " + (msg || ""));
                        }
                    }
                    Debug.assertLessThan = assertLessThan;
                    function assertLessThanOrEqual(a, b) {
                        if (a > b) {
                            fail("Expected " + a + " <= " + b);
                        }
                    }
                    Debug.assertLessThanOrEqual = assertLessThanOrEqual;
                    function assertGreaterThanOrEqual(a, b) {
                        if (a < b) {
                            fail("Expected " + a + " >= " + b);
                        }
                    }
                    Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
                    function fail(message, stackCrawlMark) {
                        debugger;
                        var e = new Error(message ? "Debug Failure. " + message : "Debug Failure.");
                        if (Error.captureStackTrace) {
                            Error.captureStackTrace(e, stackCrawlMark || fail);
                        }
                        throw e;
                    }
                    Debug.fail = fail;
                    function assertDefined(value, message) {
                        if (value === undefined || value === null)
                            return fail(message);
                        return value;
                    }
                    Debug.assertDefined = assertDefined;
                    function assertEachDefined(value, message) {
                        for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
                            var v = value_1[_i];
                            assertDefined(v, message);
                        }
                        return value;
                    }
                    Debug.assertEachDefined = assertEachDefined;
                    function assertNever(member, message, stackCrawlMark) {
                        if (message === void 0) { message = "Illegal value:"; }
                        var detail = typeof member === "object" && "kind" in member && "pos" in member ? "SyntaxKind: " + Debug.showSyntaxKind(member) : JSON.stringify(member);
                        return fail(message + " " + detail, stackCrawlMark || assertNever);
                    }
                    Debug.assertNever = assertNever;
                    function getFunctionName(func) {
                        if (typeof func !== "function") {
                            return "";
                        }
                        else if (func.hasOwnProperty("name")) {
                            return func.name;
                        }
                        else {
                            var text = Function.prototype.toString.call(func);
                            var match = /^function\s+([\w\$]+)\s*\(/.exec(text);
                            return match ? match[1] : "";
                        }
                    }
                    Debug.getFunctionName = getFunctionName;
                })(Debug = ts.Debug || (ts.Debug = {}));
                function equateValues(a, b) {
                    return a === b;
                }
                ts.equateValues = equateValues;
                /**
                 * Compare the equality of two strings using a case-sensitive ordinal comparison.
                 *
                 * Case-sensitive comparisons compare both strings one code-point at a time using the integer
                 * value of each code-point after applying `toUpperCase` to each string. We always map both
                 * strings to their upper-case form as some unicode characters do not properly round-trip to
                 * lowercase (such as `ẞ` (German sharp capital s)).
                 */
                function equateStringsCaseInsensitive(a, b) {
                    return a === b
                        || a !== undefined
                            && b !== undefined
                            && a.toUpperCase() === b.toUpperCase();
                }
                ts.equateStringsCaseInsensitive = equateStringsCaseInsensitive;
                /**
                 * Compare the equality of two strings using a case-sensitive ordinal comparison.
                 *
                 * Case-sensitive comparisons compare both strings one code-point at a time using the
                 * integer value of each code-point.
                 */
                function equateStringsCaseSensitive(a, b) {
                    return equateValues(a, b);
                }
                ts.equateStringsCaseSensitive = equateStringsCaseSensitive;
                function compareComparableValues(a, b) {
                    return a === b ? 0 /* EqualTo */ :
                        a === undefined ? -1 /* LessThan */ :
                            b === undefined ? 1 /* GreaterThan */ :
                                a < b ? -1 /* LessThan */ :
                                    1 /* GreaterThan */;
                }
                /**
                 * Compare two numeric values for their order relative to each other.
                 * To compare strings, use any of the `compareStrings` functions.
                 */
                function compareValues(a, b) {
                    return compareComparableValues(a, b);
                }
                ts.compareValues = compareValues;
                function min(a, b, compare) {
                    return compare(a, b) === -1 /* LessThan */ ? a : b;
                }
                ts.min = min;
                /**
                 * Compare two strings using a case-insensitive ordinal comparison.
                 *
                 * Ordinal comparisons are based on the difference between the unicode code points of both
                 * strings. Characters with multiple unicode representations are considered unequal. Ordinal
                 * comparisons provide predictable ordering, but place "a" after "B".
                 *
                 * Case-insensitive comparisons compare both strings one code-point at a time using the integer
                 * value of each code-point after applying `toUpperCase` to each string. We always map both
                 * strings to their upper-case form as some unicode characters do not properly round-trip to
                 * lowercase (such as `ẞ` (German sharp capital s)).
                 */
                function compareStringsCaseInsensitive(a, b) {
                    if (a === b)
                        return 0 /* EqualTo */;
                    if (a === undefined)
                        return -1 /* LessThan */;
                    if (b === undefined)
                        return 1 /* GreaterThan */;
                    a = a.toUpperCase();
                    b = b.toUpperCase();
                    return a < b ? -1 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
                }
                ts.compareStringsCaseInsensitive = compareStringsCaseInsensitive;
                /**
                 * Compare two strings using a case-sensitive ordinal comparison.
                 *
                 * Ordinal comparisons are based on the difference between the unicode code points of both
                 * strings. Characters with multiple unicode representations are considered unequal. Ordinal
                 * comparisons provide predictable ordering, but place "a" after "B".
                 *
                 * Case-sensitive comparisons compare both strings one code-point at a time using the integer
                 * value of each code-point.
                 */
                function compareStringsCaseSensitive(a, b) {
                    return compareComparableValues(a, b);
                }
                ts.compareStringsCaseSensitive = compareStringsCaseSensitive;
                function getStringComparer(ignoreCase) {
                    return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
                }
                ts.getStringComparer = getStringComparer;
                /**
                 * Creates a string comparer for use with string collation in the UI.
                 */
                var createUIStringComparer = (function () {
                    var defaultComparer;
                    var enUSComparer;
                    var stringComparerFactory = getStringComparerFactory();
                    return createStringComparer;
                    function compareWithCallback(a, b, comparer) {
                        if (a === b)
                            return 0 /* EqualTo */;
                        if (a === undefined)
                            return -1 /* LessThan */;
                        if (b === undefined)
                            return 1 /* GreaterThan */;
                        var value = comparer(a, b);
                        return value < 0 ? -1 /* LessThan */ : value > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
                    }
                    function createIntlCollatorStringComparer(locale) {
                        // Intl.Collator.prototype.compare is bound to the collator. See NOTE in
                        // http://www.ecma-international.org/ecma-402/2.0/#sec-Intl.Collator.prototype.compare
                        var comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare;
                        return function (a, b) { return compareWithCallback(a, b, comparer); };
                    }
                    function createLocaleCompareStringComparer(locale) {
                        // if the locale is not the default locale (`undefined`), use the fallback comparer.
                        if (locale !== undefined)
                            return createFallbackStringComparer();
                        return function (a, b) { return compareWithCallback(a, b, compareStrings); };
                        function compareStrings(a, b) {
                            return a.localeCompare(b);
                        }
                    }
                    function createFallbackStringComparer() {
                        // An ordinal comparison puts "A" after "b", but for the UI we want "A" before "b".
                        // We first sort case insensitively.  So "Aaa" will come before "baa".
                        // Then we sort case sensitively, so "aaa" will come before "Aaa".
                        //
                        // For case insensitive comparisons we always map both strings to their
                        // upper-case form as some unicode characters do not properly round-trip to
                        // lowercase (such as `ẞ` (German sharp capital s)).
                        return function (a, b) { return compareWithCallback(a, b, compareDictionaryOrder); };
                        function compareDictionaryOrder(a, b) {
                            return compareStrings(a.toUpperCase(), b.toUpperCase()) || compareStrings(a, b);
                        }
                        function compareStrings(a, b) {
                            return a < b ? -1 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
                        }
                    }
                    function getStringComparerFactory() {
                        // If the host supports Intl, we use it for comparisons using the default locale.
                        if (typeof Intl === "object" && typeof Intl.Collator === "function") {
                            return createIntlCollatorStringComparer;
                        }
                        // If the host does not support Intl, we fall back to localeCompare.
                        // localeCompare in Node v0.10 is just an ordinal comparison, so don't use it.
                        if (typeof String.prototype.localeCompare === "function" &&
                            typeof String.prototype.toLocaleUpperCase === "function" &&
                            "a".localeCompare("B") < 0) {
                            return createLocaleCompareStringComparer;
                        }
                        // Otherwise, fall back to ordinal comparison:
                        return createFallbackStringComparer;
                    }
                    function createStringComparer(locale) {
                        // Hold onto common string comparers. This avoids constantly reallocating comparers during
                        // tests.
                        if (locale === undefined) {
                            return defaultComparer || (defaultComparer = stringComparerFactory(locale));
                        }
                        else if (locale === "en-US") {
                            return enUSComparer || (enUSComparer = stringComparerFactory(locale));
                        }
                        else {
                            return stringComparerFactory(locale);
                        }
                    }
                })();
                var uiComparerCaseSensitive;
                var uiLocale;
                function getUILocale() {
                    return uiLocale;
                }
                ts.getUILocale = getUILocale;
                function setUILocale(value) {
                    if (uiLocale !== value) {
                        uiLocale = value;
                        uiComparerCaseSensitive = undefined;
                    }
                }
                ts.setUILocale = setUILocale;
                /**
                 * Compare two strings in a using the case-sensitive sort behavior of the UI locale.
                 *
                 * Ordering is not predictable between different host locales, but is best for displaying
                 * ordered data for UI presentation. Characters with multiple unicode representations may
                 * be considered equal.
                 *
                 * Case-sensitive comparisons compare strings that differ in base characters, or
                 * accents/diacritic marks, or case as unequal.
                 */
                function compareStringsCaseSensitiveUI(a, b) {
                    var comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = createUIStringComparer(uiLocale));
                    return comparer(a, b);
                }
                ts.compareStringsCaseSensitiveUI = compareStringsCaseSensitiveUI;
                function compareProperties(a, b, key, comparer) {
                    return a === b ? 0 /* EqualTo */ :
                        a === undefined ? -1 /* LessThan */ :
                            b === undefined ? 1 /* GreaterThan */ :
                                comparer(a[key], b[key]);
                }
                ts.compareProperties = compareProperties;
                /** True is greater than false. */
                function compareBooleans(a, b) {
                    return compareValues(a ? 1 : 0, b ? 1 : 0);
                }
                ts.compareBooleans = compareBooleans;
                /**
                 * Given a name and a list of names that are *not* equal to the name, return a spelling suggestion if there is one that is close enough.
                 * Names less than length 3 only check for case-insensitive equality, not Levenshtein distance.
                 *
                 * If there is a candidate that's the same except for case, return that.
                 * If there is a candidate that's within one edit of the name, return that.
                 * Otherwise, return the candidate with the smallest Levenshtein distance,
                 *    except for candidates:
                 *      * With no name
                 *      * Whose length differs from the target name by more than 0.34 of the length of the name.
                 *      * Whose levenshtein distance is more than 0.4 of the length of the name
                 *        (0.4 allows 1 substitution/transposition for every 5 characters,
                 *         and 1 insertion/deletion at 3 characters)
                 */
                function getSpellingSuggestion(name, candidates, getName) {
                    var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
                    var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result isn't better than this, don't bother.
                    var bestCandidate;
                    var justCheckExactMatches = false;
                    var nameLowerCase = name.toLowerCase();
                    for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
                        var candidate = candidates_1[_i];
                        var candidateName = getName(candidate);
                        if (candidateName !== undefined && Math.abs(candidateName.length - nameLowerCase.length) <= maximumLengthDifference) {
                            var candidateNameLowerCase = candidateName.toLowerCase();
                            if (candidateNameLowerCase === nameLowerCase) {
                                if (candidateName === name) {
                                    continue;
                                }
                                return candidate;
                            }
                            if (justCheckExactMatches) {
                                continue;
                            }
                            if (candidateName.length < 3) {
                                // Don't bother, user would have noticed a 2-character name having an extra character
                                continue;
                            }
                            // Only care about a result better than the best so far.
                            var distance = levenshteinWithMax(nameLowerCase, candidateNameLowerCase, bestDistance - 1);
                            if (distance === undefined) {
                                continue;
                            }
                            if (distance < 3) {
                                justCheckExactMatches = true;
                                bestCandidate = candidate;
                            }
                            else {
                                Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined
                                bestDistance = distance;
                                bestCandidate = candidate;
                            }
                        }
                    }
                    return bestCandidate;
                }
                ts.getSpellingSuggestion = getSpellingSuggestion;
                function levenshteinWithMax(s1, s2, max) {
                    var previous = new Array(s2.length + 1);
                    var current = new Array(s2.length + 1);
                    /** Represents any value > max. We don't care about the particular value. */
                    var big = max + 1;
                    for (var i = 0; i <= s2.length; i++) {
                        previous[i] = i;
                    }
                    for (var i = 1; i <= s1.length; i++) {
                        var c1 = s1.charCodeAt(i - 1);
                        var minJ = i > max ? i - max : 1;
                        var maxJ = s2.length > max + i ? max + i : s2.length;
                        current[0] = i;
                        /** Smallest value of the matrix in the ith column. */
                        var colMin = i;
                        for (var j = 1; j < minJ; j++) {
                            current[j] = big;
                        }
                        for (var j = minJ; j <= maxJ; j++) {
                            var dist = c1 === s2.charCodeAt(j - 1)
                                ? previous[j - 1]
                                : Math.min(/*delete*/ previous[j] + 1, /*insert*/ current[j - 1] + 1, /*substitute*/ previous[j - 1] + 2);
                            current[j] = dist;
                            colMin = Math.min(colMin, dist);
                        }
                        for (var j = maxJ + 1; j <= s2.length; j++) {
                            current[j] = big;
                        }
                        if (colMin > max) {
                            // Give up -- everything in this column is > max and it can't get better in future columns.
                            return undefined;
                        }
                        var temp = previous;
                        previous = current;
                        current = temp;
                    }
                    var res = previous[s2.length];
                    return res > max ? undefined : res;
                }
                function endsWith(str, suffix) {
                    var expectedPos = str.length - suffix.length;
                    return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
                }
                ts.endsWith = endsWith;
                function removeSuffix(str, suffix) {
                    return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str;
                }
                ts.removeSuffix = removeSuffix;
                function tryRemoveSuffix(str, suffix) {
                    return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : undefined;
                }
                ts.tryRemoveSuffix = tryRemoveSuffix;
                function stringContains(str, substring) {
                    return str.indexOf(substring) !== -1;
                }
                ts.stringContains = stringContains;
                function fileExtensionIs(path, extension) {
                    return path.length > extension.length && endsWith(path, extension);
                }
                ts.fileExtensionIs = fileExtensionIs;
                function fileExtensionIsOneOf(path, extensions) {
                    for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
                        var extension = extensions_1[_i];
                        if (fileExtensionIs(path, extension)) {
                            return true;
                        }
                    }
                    return false;
                }
                ts.fileExtensionIsOneOf = fileExtensionIsOneOf;
                /**
                 * Takes a string like "jquery-min.4.2.3" and returns "jquery"
                 */
                function removeMinAndVersionNumbers(fileName) {
                    // Match a "." or "-" followed by a version number or 'min' at the end of the name
                    var trailingMinOrVersion = /[.-]((min)|(\d+(\.\d+)*))$/;
                    // The "min" or version may both be present, in either order, so try applying the above twice.
                    return fileName.replace(trailingMinOrVersion, "").replace(trailingMinOrVersion, "");
                }
                ts.removeMinAndVersionNumbers = removeMinAndVersionNumbers;
                /** Remove an item from an array, moving everything to its right one space left. */
                function orderedRemoveItem(array, item) {
                    for (var i = 0; i < array.length; i++) {
                        if (array[i] === item) {
                            orderedRemoveItemAt(array, i);
                            return true;
                        }
                    }
                    return false;
                }
                ts.orderedRemoveItem = orderedRemoveItem;
                /** Remove an item by index from an array, moving everything to its right one space left. */
                function orderedRemoveItemAt(array, index) {
                    // This seems to be faster than either `array.splice(i, 1)` or `array.copyWithin(i, i+ 1)`.
                    for (var i = index; i < array.length - 1; i++) {
                        array[i] = array[i + 1];
                    }
                    array.pop();
                }
                ts.orderedRemoveItemAt = orderedRemoveItemAt;
                function unorderedRemoveItemAt(array, index) {
                    // Fill in the "hole" left at `index`.
                    array[index] = array[array.length - 1];
                    array.pop();
                }
                ts.unorderedRemoveItemAt = unorderedRemoveItemAt;
                /** Remove the *first* occurrence of `item` from the array. */
                function unorderedRemoveItem(array, item) {
                    return unorderedRemoveFirstItemWhere(array, function (element) { return element === item; });
                }
                ts.unorderedRemoveItem = unorderedRemoveItem;
                /** Remove the *first* element satisfying `predicate`. */
                function unorderedRemoveFirstItemWhere(array, predicate) {
                    for (var i = 0; i < array.length; i++) {
                        if (predicate(array[i])) {
                            unorderedRemoveItemAt(array, i);
                            return true;
                        }
                    }
                    return false;
                }
                function createGetCanonicalFileName(useCaseSensitiveFileNames) {
                    return useCaseSensitiveFileNames ? identity : toLowerCase;
                }
                ts.createGetCanonicalFileName = createGetCanonicalFileName;
                function patternText(_a) {
                    var prefix = _a.prefix, suffix = _a.suffix;
                    return prefix + "*" + suffix;
                }
                ts.patternText = patternText;
                /**
                 * Given that candidate matches pattern, returns the text matching the '*'.
                 * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
                 */
                function matchedText(pattern, candidate) {
                    Debug.assert(isPatternMatch(pattern, candidate));
                    return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
                }
                ts.matchedText = matchedText;
                /** Return the object corresponding to the best pattern to match `candidate`. */
                function findBestPatternMatch(values, getPattern, candidate) {
                    var matchedValue;
                    // use length of prefix as betterness criteria
                    var longestMatchPrefixLength = -1;
                    for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {
                        var v = values_2[_i];
                        var pattern = getPattern(v);
                        if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
                            longestMatchPrefixLength = pattern.prefix.length;
                            matchedValue = v;
                        }
                    }
                    return matchedValue;
                }
                ts.findBestPatternMatch = findBestPatternMatch;
                function startsWith(str, prefix) {
                    return str.lastIndexOf(prefix, 0) === 0;
                }
                ts.startsWith = startsWith;
                function removePrefix(str, prefix) {
                    return startsWith(str, prefix) ? str.substr(prefix.length) : str;
                }
                ts.removePrefix = removePrefix;
                function tryRemovePrefix(str, prefix, getCanonicalFileName) {
                    if (getCanonicalFileName === void 0) { getCanonicalFileName = identity; }
                    return startsWith(getCanonicalFileName(str), getCanonicalFileName(prefix)) ? str.substring(prefix.length) : undefined;
                }
                ts.tryRemovePrefix = tryRemovePrefix;
                function isPatternMatch(_a, candidate) {
                    var prefix = _a.prefix, suffix = _a.suffix;
                    return candidate.length >= prefix.length + suffix.length &&
                        startsWith(candidate, prefix) &&
                        endsWith(candidate, suffix);
                }
                function and(f, g) {
                    return function (arg) { return f(arg) && g(arg); };
                }
                ts.and = and;
                function or(f, g) {
                    return function (arg) { return f(arg) || g(arg); };
                }
                ts.or = or;
                function assertType(_) { } // tslint:disable-line no-empty
                ts.assertType = assertType;
                function singleElementArray(t) {
                    return t === undefined ? undefined : [t];
                }
                ts.singleElementArray = singleElementArray;
                function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) {
                    unchanged = unchanged || noop;
                    var newIndex = 0;
                    var oldIndex = 0;
                    var newLen = newItems.length;
                    var oldLen = oldItems.length;
                    while (newIndex < newLen && oldIndex < oldLen) {
                        var newItem = newItems[newIndex];
                        var oldItem = oldItems[oldIndex];
                        var compareResult = comparer(newItem, oldItem);
                        if (compareResult === -1 /* LessThan */) {
                            inserted(newItem);
                            newIndex++;
                        }
                        else if (compareResult === 1 /* GreaterThan */) {
                            deleted(oldItem);
                            oldIndex++;
                        }
                        else {
                            unchanged(oldItem, newItem);
                            newIndex++;
                            oldIndex++;
                        }
                    }
                    while (newIndex < newLen) {
                        inserted(newItems[newIndex++]);
                    }
                    while (oldIndex < oldLen) {
                        deleted(oldItems[oldIndex++]);
                    }
                }
                ts.enumerateInsertsAndDeletes = enumerateInsertsAndDeletes;
                function fill(length, cb) {
                    var result = Array(length);
                    for (var i = 0; i < length; i++) {
                        result[i] = cb(i);
                    }
                    return result;
                }
                ts.fill = fill;
            })(ts || (ts = {}));
            /*@internal*/
            var ts;
            (function (ts) {
                /** Gets a timestamp with (at least) ms resolution */
                ts.timestamp = typeof performance !== "undefined" && performance.now ? function () { return performance.now(); } : Date.now ? Date.now : function () { return +(new Date()); };
            })(ts || (ts = {}));
            /*@internal*/
            /** Performance measurements for the compiler. */
            (function (ts) {
                var performance;
                (function (performance) {
                    // NOTE: cannot use ts.noop as core.ts loads after this
                    var profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true ? onProfilerEvent : function () { };
                    var enabled = false;
                    var profilerStart = 0;
                    var counts;
                    var marks;
                    var measures;
                    function createTimerIf(condition, measureName, startMarkName, endMarkName) {
                        return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer;
                    }
                    performance.createTimerIf = createTimerIf;
                    function createTimer(measureName, startMarkName, endMarkName) {
                        var enterCount = 0;
                        return {
                            enter: enter,
                            exit: exit
                        };
                        function enter() {
                            if (++enterCount === 1) {
                                mark(startMarkName);
                            }
                        }
                        function exit() {
                            if (--enterCount === 0) {
                                mark(endMarkName);
                                measure(measureName, startMarkName, endMarkName);
                            }
                            else if (enterCount < 0) {
                                ts.Debug.fail("enter/exit count does not match.");
                            }
                        }
                    }
                    performance.createTimer = createTimer;
                    performance.nullTimer = { enter: ts.noop, exit: ts.noop };
                    /**
                     * Marks a performance event.
                     *
                     * @param markName The name of the mark.
                     */
                    function mark(markName) {
                        if (enabled) {
                            marks.set(markName, ts.timestamp());
                            counts.set(markName, (counts.get(markName) || 0) + 1);
                            profilerEvent(markName);
                        }
                    }
                    performance.mark = mark;
                    /**
                     * Adds a performance measurement with the specified name.
                     *
                     * @param measureName The name of the performance measurement.
                     * @param startMarkName The name of the starting mark. If not supplied, the point at which the
                     *      profiler was enabled is used.
                     * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is
                     *      used.
                     */
                    function measure(measureName, startMarkName, endMarkName) {
                        if (enabled) {
                            var end = endMarkName && marks.get(endMarkName) || ts.timestamp();
                            var start = startMarkName && marks.get(startMarkName) || profilerStart;
                            measures.set(measureName, (measures.get(measureName) || 0) + (end - start));
                        }
                    }
                    performance.measure = measure;
                    /**
                     * Gets the number of times a marker was encountered.
                     *
                     * @param markName The name of the mark.
                     */
                    function getCount(markName) {
                        return counts && counts.get(markName) || 0;
                    }
                    performance.getCount = getCount;
                    /**
                     * Gets the total duration of all measurements with the supplied name.
                     *
                     * @param measureName The name of the measure whose durations should be accumulated.
                     */
                    function getDuration(measureName) {
                        return measures && measures.get(measureName) || 0;
                    }
                    performance.getDuration = getDuration;
                    /**
                     * Iterate over each measure, performing some action
                     *
                     * @param cb The action to perform for each measure
                     */
                    function forEachMeasure(cb) {
                        measures.forEach(function (measure, key) {
                            cb(key, measure);
                        });
                    }
                    performance.forEachMeasure = forEachMeasure;
                    /** Enables (and resets) performance measurements for the compiler. */
                    function enable() {
                        counts = ts.createMap();
                        marks = ts.createMap();
                        measures = ts.createMap();
                        enabled = true;
                        profilerStart = ts.timestamp();
                    }
                    performance.enable = enable;
                    /** Disables performance measurements for the compiler. */
                    function disable() {
                        enabled = false;
                    }
                    performance.disable = disable;
                })(performance = ts.performance || (ts.performance = {}));
            })(ts || (ts = {}));
            /* @internal */
            var ts;
            (function (ts) {
                // https://semver.org/#spec-item-2
                // > A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative
                // > integers, and MUST NOT contain leading zeroes. X is the major version, Y is the minor
                // > version, and Z is the patch version. Each element MUST increase numerically.
                //
                // NOTE: We differ here in that we allow X and X.Y, with missing parts having the default
                // value of `0`.
                var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
                // https://semver.org/#spec-item-9
                // > A pre-release version MAY be denoted by appending a hyphen and a series of dot separated
                // > identifiers immediately following the patch version. Identifiers MUST comprise only ASCII
                // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers
                // > MUST NOT include leading zeroes.
                var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
                // https://semver.org/#spec-item-10
                // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated
                // > identifiers immediately following the patch or pre-release version. Identifiers MUST
                // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
                var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
                // https://semver.org/#spec-item-9
                // > Numeric identifiers MUST NOT include leading zeroes.
                var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
                /**
                 * Describes a precise semantic version number, https://semver.org
                 */
                var Version = /** @class */ (function () {
                    function Version(major, minor, patch, prerelease, build) {
                        if (minor === void 0) { minor = 0; }
                        if (patch === void 0) { patch = 0; }
                        if (prerelease === void 0) { prerelease = ""; }
                        if (build === void 0) { build = ""; }
                        if (typeof major === "string") {
                            var result = ts.Debug.assertDefined(tryParseComponents(major), "Invalid version");
                            (major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build);
                        }
                        ts.Debug.assert(major >= 0, "Invalid argument: major");
                        ts.Debug.assert(minor >= 0, "Invalid argument: minor");
                        ts.Debug.assert(patch >= 0, "Invalid argument: patch");
                        ts.Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease");
                        ts.Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build");
                        this.major = major;
                        this.minor = minor;
                        this.patch = patch;
                        this.prerelease = prerelease ? prerelease.split(".") : ts.emptyArray;
                        this.build = build ? build.split(".") : ts.emptyArray;
                    }
                    Version.tryParse = function (text) {
                        var result = tryParseComponents(text);
                        if (!result)
                            return undefined;
                        var major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build;
                        return new Version(major, minor, patch, prerelease, build);
                    };
                    Version.prototype.compareTo = function (other) {
                        // https://semver.org/#spec-item-11
                        // > Precedence is determined by the first difference when comparing each of these
                        // > identifiers from left to right as follows: Major, minor, and patch versions are
                        // > always compared numerically.
                        //
                        // https://semver.org/#spec-item-11
                        // > Precedence for two pre-release versions with the same major, minor, and patch version
                        // > MUST be determined by comparing each dot separated identifier from left to right until
                        // > a difference is found [...]
                        //
                        // https://semver.org/#spec-item-11
                        // > Build metadata does not figure into precedence
                        if (this === other)
                            return 0 /* EqualTo */;
                        if (other === undefined)
                            return 1 /* GreaterThan */;
                        return ts.compareValues(this.major, other.major)
                            || ts.compareValues(this.minor, other.minor)
                            || ts.compareValues(this.patch, other.patch)
                            || comparePrerelaseIdentifiers(this.prerelease, other.prerelease);
                    };
                    Version.prototype.increment = function (field) {
                        switch (field) {
                            case "major": return new Version(this.major + 1, 0, 0);
                            case "minor": return new Version(this.major, this.minor + 1, 0);
                            case "patch": return new Version(this.major, this.minor, this.patch + 1);
                            default: return ts.Debug.assertNever(field);
                        }
                    };
                    Version.prototype.toString = function () {
                        var result = this.major + "." + this.minor + "." + this.patch;
                        if (ts.some(this.prerelease))
                            result += "-" + this.prerelease.join(".");
                        if (ts.some(this.build))
                            result += "+" + this.build.join(".");
                        return result;
                    };
                    Version.zero = new Version(0, 0, 0);
                    return Version;
                }());
                ts.Version = Version;
                function tryParseComponents(text) {
                    var match = versionRegExp.exec(text);
                    if (!match)
                        return undefined;
                    var major = match[1], _a = match[2], minor = _a === void 0 ? "0" : _a, _b = match[3], patch = _b === void 0 ? "0" : _b, _c = match[4], prerelease = _c === void 0 ? "" : _c, _d = match[5], build = _d === void 0 ? "" : _d;
                    if (prerelease && !prereleaseRegExp.test(prerelease))
                        return undefined;
                    if (build && !buildRegExp.test(build))
                        return undefined;
                    return {
                        major: parseInt(major, 10),
                        minor: parseInt(minor, 10),
                        patch: parseInt(patch, 10),
                        prerelease: prerelease,
                        build: build
                    };
                }
                function comparePrerelaseIdentifiers(left, right) {
                    // https://semver.org/#spec-item-11
                    // > When major, minor, and patch are equal, a pre-release version has lower precedence
                    // > than a normal version.
                    if (left === right)
                        return 0 /* EqualTo */;
                    if (left.length === 0)
                        return right.length === 0 ? 0 /* EqualTo */ : 1 /* GreaterThan */;
                    if (right.length === 0)
                        return -1 /* LessThan */;
                    // https://semver.org/#spec-item-11
                    // > Precedence for two pre-release versions with the same major, minor, and patch version
                    // > MUST be determined by comparing each dot separated identifier from left to right until
                    // > a difference is found [...]
                    var length = Math.min(left.length, right.length);
                    for (var i = 0; i < length; i++) {
                        var leftIdentifier = left[i];
                        var rightIdentifier = right[i];
                        if (leftIdentifier === rightIdentifier)
                            continue;
                        var leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier);
                        var rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier);
                        if (leftIsNumeric || rightIsNumeric) {
                            // https://semver.org/#spec-item-11
                            // > Numeric identifiers always have lower precedence than non-numeric identifiers.
                            if (leftIsNumeric !== rightIsNumeric)
                                return leftIsNumeric ? -1 /* LessThan */ : 1 /* GreaterThan */;
                            // https://semver.org/#spec-item-11
                            // > identifiers consisting of only digits are compared numerically
                            var result = ts.compareValues(+leftIdentifier, +rightIdentifier);
                            if (result)
                                return result;
                        }
                        else {
                            // https://semver.org/#spec-item-11
                            // > identifiers with letters or hyphens are compared lexically in ASCII sort order.
                            var result = ts.compareStringsCaseSensitive(leftIdentifier, rightIdentifier);
                            if (result)
                                return result;
                        }
                    }
                    // https://semver.org/#spec-item-11
                    // > A larger set of pre-release fields has a higher precedence than a smaller set, if all
                    // > of the preceding identifiers are equal.
                    return ts.compareValues(left.length, right.length);
                }
                /**
                 * Describes a semantic version range, per https://github.com/npm/node-semver#ranges
                 */
                var VersionRange = /** @class */ (function () {
                    function VersionRange(spec) {
                        this._alternatives = spec ? ts.Debug.assertDefined(parseRange(spec), "Invalid range spec.") : ts.emptyArray;
                    }
                    VersionRange.tryParse = function (text) {
                        var sets = parseRange(text);
                        if (sets) {
                            var range = new VersionRange("");
                            range._alternatives = sets;
                            return range;
                        }
                        return undefined;
                    };
                    VersionRange.prototype.test = function (version) {
                        if (typeof version === "string")
                            version = new Version(version);
                        return testDisjunction(version, this._alternatives);
                    };
                    VersionRange.prototype.toString = function () {
                        return formatDisjunction(this._alternatives);
                    };
                    return VersionRange;
                }());
                ts.VersionRange = VersionRange;
                // https://github.com/npm/node-semver#range-grammar
                //
                // range-set    ::= range ( logical-or range ) *
                // range        ::= hyphen | simple ( ' ' simple ) * | ''
                // logical-or   ::= ( ' ' ) * '||' ( ' ' ) *
                var logicalOrRegExp = /\s*\|\|\s*/g;
                var whitespaceRegExp = /\s+/g;
                // https://github.com/npm/node-semver#range-grammar
                //
                // partial      ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
                // xr           ::= 'x' | 'X' | '*' | nr
                // nr           ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
                // qualifier    ::= ( '-' pre )? ( '+' build )?
                // pre          ::= parts
                // build        ::= parts
                // parts        ::= part ( '.' part ) *
                // part         ::= nr | [-0-9A-Za-z]+
                var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
                // https://github.com/npm/node-semver#range-grammar
                //
                // hyphen       ::= partial ' - ' partial
                var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i;
                // https://github.com/npm/node-semver#range-grammar
                //
                // simple       ::= primitive | partial | tilde | caret
                // primitive    ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
                // tilde        ::= '~' partial
                // caret        ::= '^' partial
                var rangeRegExp = /^\s*(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i;
                function parseRange(text) {
                    var alternatives = [];
                    for (var _i = 0, _a = text.trim().split(logicalOrRegExp); _i < _a.length; _i++) {
                        var range = _a[_i];
                        if (!range)
                            continue;
                        var comparators = [];
                        var match = hyphenRegExp.exec(range);
                        if (match) {
                            if (!parseHyphen(match[1], match[2], comparators))
                                return undefined;
                        }
                        else {
                            for (var _b = 0, _c = range.split(whitespaceRegExp); _b < _c.length; _b++) {
                                var simple = _c[_b];
                                var match_1 = rangeRegExp.exec(simple);
                                if (!match_1 || !parseComparator(match_1[1], match_1[2], comparators))
                                    return undefined;
                            }
                        }
                        alternatives.push(comparators);
                    }
                    return alternatives;
                }
                function parsePartial(text) {
                    var match = partialRegExp.exec(text);
                    if (!match)
                        return undefined;
                    var major = match[1], _a = match[2], minor = _a === void 0 ? "*" : _a, _b = match[3], patch = _b === void 0 ? "*" : _b, prerelease = match[4], build = match[5];
                    var version = new Version(isWildcard(major) ? 0 : parseInt(major, 10), isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10), isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10), prerelease, build);
                    return { version: version, major: major, minor: minor, patch: patch };
                }
                function parseHyphen(left, right, comparators) {
                    var leftResult = parsePartial(left);
                    if (!leftResult)
                        return false;
                    var rightResult = parsePartial(right);
                    if (!rightResult)
                        return false;
                    if (!isWildcard(leftResult.major)) {
                        comparators.push(createComparator(">=", leftResult.version));
                    }
                    if (!isWildcard(rightResult.major)) {
                        comparators.push(isWildcard(rightResult.minor) ? createComparator("<", rightResult.version.increment("major")) :
                            isWildcard(rightResult.patch) ? createComparator("<", rightResult.version.increment("minor")) :
                                createComparator("<=", rightResult.version));
                    }
                    return true;
                }
                function parseComparator(operator, text, comparators) {
                    var result = parsePartial(text);
                    if (!result)
                        return false;
                    var version = result.version, major = result.major, minor = result.minor, patch = result.patch;
                    if (!isWildcard(major)) {
                        switch (operator) {
                            case "~":
                                comparators.push(createComparator(">=", version));
                                comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" :
                                    "minor")));
                                break;
                            case "^":
                                comparators.push(createComparator(">=", version));
                                comparators.push(createComparator("<", version.increment(version.major > 0 || isWildcard(minor) ? "major" :
                                    version.minor > 0 || isWildcard(patch) ? "minor" :
                                        "patch")));
                                break;
                            case "<":
                            case ">=":
                                comparators.push(createComparator(operator, version));
                                break;
                            case "<=":
                            case ">":
                                comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) :
                                    isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) :
                                        createComparator(operator, version));
                                break;
                            case "=":
                            case undefined:
                                if (isWildcard(minor) || isWildcard(patch)) {
                                    comparators.push(createComparator(">=", version));
                                    comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor")));
                                }
                                else {
                                    comparators.push(createComparator("=", version));
                                }
                                break;
                            default:
                                // unrecognized
                                return false;
                        }
                    }
                    else if (operator === "<" || operator === ">") {
                        comparators.push(createComparator("<", Version.zero));
                    }
                    return true;
                }
                function isWildcard(part) {
                    return part === "*" || part === "x" || part === "X";
                }
                function createComparator(operator, operand) {
                    return { operator: operator, operand: operand };
                }
                function testDisjunction(version, alternatives) {
                    // an empty disjunction is treated as "*" (all versions)
                    if (alternatives.length === 0)
                        return true;
                    for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) {
                        var alternative = alternatives_1[_i];
                        if (testAlternative(version, alternative))
                            return true;
                    }
                    return false;
                }
                function testAlternative(version, comparators) {
                    for (var _i = 0, comparators_1 = comparators; _i < comparators_1.length; _i++) {
                        var comparator = comparators_1[_i];
                        if (!testComparator(version, comparator.operator, comparator.operand))
                            return false;
                    }
                    return true;
                }
                function testComparator(version, operator, operand) {
                    var cmp = version.compareTo(operand);
                    switch (operator) {
                        case "<": return cmp < 0;
                        case "<=": return cmp <= 0;
                        case ">": return cmp > 0;
                        case ">=": return cmp >= 0;
                        case "=": return cmp === 0;
                        default: return ts.Debug.assertNever(operator);
                    }
                }
                function formatDisjunction(alternatives) {
                    return ts.map(alternatives, formatAlternative).join(" || ") || "*";
                }
                function formatAlternative(comparators) {
                    return ts.map(comparators, formatComparator).join(" ");
                }
                function formatComparator(comparator) {
                    return "" + comparator.operator + comparator.operand;
                }
            })(ts || (ts = {}));
            var ts;
            (function (ts) {
                // token > SyntaxKind.Identifier => token is a keyword
                // Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync
                var SyntaxKind;
                (function (SyntaxKind) {
                    SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown";
                    SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken";
                    SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia";
                    SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia";
                    SyntaxKind[SyntaxKind["NewLineTrivia"] = 4] = "NewLineTrivia";
                    SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 5] = "WhitespaceTrivia";
                    // We detect and preserve #! on the first line
                    SyntaxKind[SyntaxKind["ShebangTrivia"] = 6] = "ShebangTrivia";
                    // We detect and provide better error recovery when we encounter a git merge marker.  This
                    // allows us to edit files with git-conflict markers in them in a much more pleasant manner.
                    SyntaxKind[SyntaxKind["ConflictMarkerTrivia"] = 7] = "ConflictMarkerTrivia";
                    // Literals
                    SyntaxKind[SyntaxKind["NumericLiteral"] = 8] = "NumericLiteral";
                    SyntaxKind[SyntaxKind["BigIntLiteral"] = 9] = "BigIntLiteral";
                    SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
                    SyntaxKind[SyntaxKind["JsxText"] = 11] = "JsxText";
                    SyntaxKind[SyntaxKind["JsxTextAllWhiteSpaces"] = 12] = "JsxTextAllWhiteSpaces";
                    SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 13] = "RegularExpressionLiteral";
                    SyntaxKind[SyntaxKind["NoSubstitutionTemplateLiteral"] = 14] = "NoSubstitutionTemplateLiteral";
                    // Pseudo-literals
                    SyntaxKind[SyntaxKind["TemplateHead"] = 15] = "TemplateHead";
                    SyntaxKind[SyntaxKind["TemplateMiddle"] = 16] = "TemplateMiddle";
                    SyntaxKind[SyntaxKind["TemplateTail"] = 17] = "TemplateTail";
                    // Punctuation
                    SyntaxKind[SyntaxKind["OpenBraceToken"] = 18] = "OpenBraceToken";
                    SyntaxKind[SyntaxKind["CloseBraceToken"] = 19] = "CloseBraceToken";
                    SyntaxKind[SyntaxKind["OpenParenToken"] = 20] = "OpenParenToken";
                    SyntaxKind[SyntaxKind["CloseParenToken"] = 21] = "CloseParenToken";
                    SyntaxKind[SyntaxKind["OpenBracketToken"] = 22] = "OpenBracketToken";
                    SyntaxKind[SyntaxKind["CloseBracketToken"] = 23] = "CloseBracketToken";
                    SyntaxKind[SyntaxKind["DotToken"] = 24] = "DotToken";
                    SyntaxKind[SyntaxKind["DotDotDotToken"] = 25] = "DotDotDotToken";
                    SyntaxKind[SyntaxKind["SemicolonToken"] = 26] = "SemicolonToken";
                    SyntaxKind[SyntaxKind["CommaToken"] = 27] = "CommaToken";
                    SyntaxKind[SyntaxKind["LessThanToken"] = 28] = "LessThanToken";
                    SyntaxKind[SyntaxKind["LessThanSlashToken"] = 29] = "LessThanSlashToken";
                    SyntaxKind[SyntaxKind["GreaterThanToken"] = 30] = "GreaterThanToken";
                    SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 31] = "LessThanEqualsToken";
                    SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 32] = "GreaterThanEqualsToken";
                    SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 33] = "EqualsEqualsToken";
                    SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 34] = "ExclamationEqualsToken";
                    SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 35] = "EqualsEqualsEqualsToken";
                    SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 36] = "ExclamationEqualsEqualsToken";
                    SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 37] = "EqualsGreaterThanToken";
                    SyntaxKind[SyntaxKind["PlusToken"] = 38] = "PlusToken";
                    SyntaxKind[SyntaxKind["MinusToken"] = 39] = "MinusToken";
                    SyntaxKind[SyntaxKind["AsteriskToken"] = 40] = "AsteriskToken";
                    SyntaxKind[SyntaxKind["AsteriskAsteriskToken"] = 41] = "AsteriskAsteriskToken";
                    SyntaxKind[SyntaxKind["SlashToken"] = 42] = "SlashToken";
                    SyntaxKind[SyntaxKind["PercentToken"] = 43] = "PercentToken";
                    SyntaxKind[SyntaxKind["PlusPlusToken"] = 44] = "PlusPlusToken";
                    SyntaxKind[SyntaxKind["MinusMinusToken"] = 45] = "MinusMinusToken";
                    SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 46] = "LessThanLessThanToken";
                    SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 47] = "GreaterThanGreaterThanToken";
                    SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 48] = "GreaterThanGreaterThanGreaterThanToken";
                    SyntaxKind[SyntaxKind["AmpersandToken"] = 49] = "AmpersandToken";
                    SyntaxKind[SyntaxKind["BarToken"] = 50] = "BarToken";
                    SyntaxKind[SyntaxKind["CaretToken"] = 51] = "CaretToken";
                    SyntaxKind[SyntaxKind["ExclamationToken"] = 52] = "ExclamationToken";
                    SyntaxKind[SyntaxKind["TildeToken"] = 53] = "TildeToken";
                    SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 54] = "AmpersandAmpersandToken";
                    SyntaxKind[SyntaxKind["BarBarToken"] = 55] = "BarBarToken";
                    SyntaxKind[SyntaxKind["QuestionToken"] = 56] = "QuestionToken";
                    SyntaxKind[SyntaxKind["ColonToken"] = 57] = "ColonToken";
                    SyntaxKind[SyntaxKind["AtToken"] = 58] = "AtToken";
                    // Assignments
                    SyntaxKind[SyntaxKind["EqualsToken"] = 59] = "EqualsToken";
                    SyntaxKind[SyntaxKind["PlusEqualsToken"] = 60] = "PlusEqualsToken";
                    SyntaxKind[SyntaxKind["MinusEqualsToken"] = 61] = "MinusEqualsToken";
                    SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 62] = "AsteriskEqualsToken";
                    SyntaxKind[SyntaxKind["AsteriskAsteriskEqualsToken"] = 63] = "AsteriskAsteriskEqualsToken";
                    SyntaxKind[SyntaxKind["SlashEqualsToken"] = 64] = "SlashEqualsToken";
                    SyntaxKind[SyntaxKind["PercentEqualsToken"] = 65] = "PercentEqualsToken";
                    SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 66] = "LessThanLessThanEqualsToken";
                    SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 67] = "GreaterThanGreaterThanEqualsToken";
                    SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 68] = "GreaterThanGreaterThanGreaterThanEqualsToken";
                    SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 69] = "AmpersandEqualsToken";
                    SyntaxKind[SyntaxKind["BarEqualsToken"] = 70] = "BarEqualsToken";
                    SyntaxKind[SyntaxKind["CaretEqualsToken"] = 71] = "CaretEqualsToken";
                    // Identifiers
                    SyntaxKind[SyntaxKind["Identifier"] = 72] = "Identifier";
                    // Reserved words
                    SyntaxKind[SyntaxKind["BreakKeyword"] = 73] = "BreakKeyword";
                    SyntaxKind[SyntaxKind["CaseKeyword"] = 74] = "CaseKeyword";
                    SyntaxKind[SyntaxKind["CatchKeyword"] = 75] = "CatchKeyword";
                    SyntaxKind[SyntaxKind["ClassKeyword"] = 76] = "ClassKeyword";
                    SyntaxKind[SyntaxKind["ConstKeyword"] = 77] = "ConstKeyword";
                    SyntaxKind[SyntaxKind["ContinueKeyword"] = 78] = "ContinueKeyword";
                    SyntaxKind[SyntaxKind["DebuggerKeyword"] = 79] = "DebuggerKeyword";
                    SyntaxKind[SyntaxKind["DefaultKeyword"] = 80] = "DefaultKeyword";
                    SyntaxKind[SyntaxKind["DeleteKeyword"] = 81] = "DeleteKeyword";
                    SyntaxKind[SyntaxKind["DoKeyword"] = 82] = "DoKeyword";
                    SyntaxKind[SyntaxKind["ElseKeyword"] = 83] = "ElseKeyword";
                    SyntaxKind[SyntaxKind["EnumKeyword"] = 84] = "EnumKeyword";
                    SyntaxKind[SyntaxKind["ExportKeyword"] = 85] = "ExportKeyword";
                    SyntaxKind[SyntaxKind["ExtendsKeyword"] = 86] = "ExtendsKeyword";
                    SyntaxKind[SyntaxKind["FalseKeyword"] = 87] = "FalseKeyword";
                    SyntaxKind[SyntaxKind["FinallyKeyword"] = 88] = "FinallyKeyword";
                    SyntaxKind[SyntaxKind["ForKeyword"] = 89] = "ForKeyword";
                    SyntaxKind[SyntaxKind["FunctionKeyword"] = 90] = "FunctionKeyword";
                    SyntaxKind[SyntaxKind["IfKeyword"] = 91] = "IfKeyword";
                    SyntaxKind[SyntaxKind["ImportKeyword"] = 92] = "ImportKeyword";
                    SyntaxKind[SyntaxKind["InKeyword"] = 93] = "InKeyword";
                    SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 94] = "InstanceOfKeyword";
                    SyntaxKind[SyntaxKind["NewKeyword"] = 95] = "NewKeyword";
                    SyntaxKind[SyntaxKind["NullKeyword"] = 96] = "NullKeyword";
                    SyntaxKind[SyntaxKind["ReturnKeyword"] = 97] = "ReturnKeyword";
                    SyntaxKind[SyntaxKind["SuperKeyword"] = 98] = "SuperKeyword";
                    SyntaxKind[SyntaxKind["SwitchKeyword"] = 99] = "SwitchKeyword";
                    SyntaxKind[SyntaxKind["ThisKeyword"] = 100] = "ThisKeyword";
                    SyntaxKind[SyntaxKind["ThrowKeyword"] = 101] = "ThrowKeyword";
                    SyntaxKind[SyntaxKind["TrueKeyword"] = 102] = "TrueKeyword";
                    SyntaxKind[SyntaxKind["TryKeyword"] = 103] = "TryKeyword";
                    SyntaxKind[SyntaxKind["TypeOfKeyword"] = 104] = "TypeOfKeyword";
                    SyntaxKind[SyntaxKind["VarKeyword"] = 105] = "VarKeyword";
                    SyntaxKind[SyntaxKind["VoidKeyword"] = 106] = "VoidKeyword";
                    SyntaxKind[SyntaxKind["WhileKeyword"] = 107] = "WhileKeyword";
                    SyntaxKind[SyntaxKind["WithKeyword"] = 108] = "WithKeyword";
                    // Strict mode reserved words
                    SyntaxKind[SyntaxKind["ImplementsKeyword"] = 109] = "ImplementsKeyword";
                    SyntaxKind[SyntaxKind["InterfaceKeyword"] = 110] = "InterfaceKeyword";
                    SyntaxKind[SyntaxKind["LetKeyword"] = 111] = "LetKeyword";
                    SyntaxKind[SyntaxKind["PackageKeyword"] = 112] = "PackageKeyword";
                    SyntaxKind[SyntaxKind["PrivateKeyword"] = 113] = "PrivateKeyword";
                    SyntaxKind[SyntaxKind["ProtectedKeyword"] = 114] = "ProtectedKeyword";
                    SyntaxKind[SyntaxKind["PublicKeyword"] = 115] = "PublicKeyword";
                    SyntaxKind[SyntaxKind["StaticKeyword"] = 116] = "StaticKeyword";
                    SyntaxKind[SyntaxKind["YieldKeyword"] = 117] = "YieldKeyword";
                    // Contextual keywords
                    SyntaxKind[SyntaxKind["AbstractKeyword"] = 118] = "AbstractKeyword";
                    SyntaxKind[SyntaxKind["AsKeyword"] = 119] = "AsKeyword";
                    SyntaxKind[SyntaxKind["AnyKeyword"] = 120] = "AnyKeyword";
                    SyntaxKind[SyntaxKind["AsyncKeyword"] = 121] = "AsyncKeyword";
                    SyntaxKind[SyntaxKind["AwaitKeyword"] = 122] = "AwaitKeyword";
                    SyntaxKind[SyntaxKind["BooleanKeyword"] = 123] = "BooleanKeyword";
                    SyntaxKind[SyntaxKind["ConstructorKeyword"] = 124] = "ConstructorKeyword";
                    SyntaxKind[SyntaxKind["DeclareKeyword"] = 125] = "DeclareKeyword";
                    SyntaxKind[SyntaxKind["GetKeyword"] = 126] = "GetKeyword";
                    SyntaxKind[SyntaxKind["InferKeyword"] = 127] = "InferKeyword";
                    SyntaxKind[SyntaxKind["IsKeyword"] = 128] = "IsKeyword";
                    SyntaxKind[SyntaxKind["KeyOfKeyword"] = 129] = "KeyOfKeyword";
                    SyntaxKind[SyntaxKind["ModuleKeyword"] = 130] = "ModuleKeyword";
                    SyntaxKind[SyntaxKind["NamespaceKeyword"] = 131] = "NamespaceKeyword";
                    SyntaxKind[SyntaxKind["NeverKeyword"] = 132] = "NeverKeyword";
                    SyntaxKind[SyntaxKind["ReadonlyKeyword"] = 133] = "ReadonlyKeyword";
                    SyntaxKind[SyntaxKind["RequireKeyword"] = 134] = "RequireKeyword";
                    SyntaxKind[SyntaxKind["NumberKeyword"] = 135] = "NumberKeyword";
                    SyntaxKind[SyntaxKind["ObjectKeyword"] = 136] = "ObjectKeyword";
                    SyntaxKind[SyntaxKind["SetKeyword"] = 137] = "SetKeyword";
                    SyntaxKind[SyntaxKind["StringKeyword"] = 138] = "StringKeyword";
                    SyntaxKind[SyntaxKind["SymbolKeyword"] = 139] = "SymbolKeyword";
                    SyntaxKind[SyntaxKind["TypeKeyword"] = 140] = "TypeKeyword";
                    SyntaxKind[SyntaxKind["UndefinedKeyword"] = 141] = "UndefinedKeyword";
                    SyntaxKind[SyntaxKind["UniqueKeyword"] = 142] = "UniqueKeyword";
                    SyntaxKind[SyntaxKind["UnknownKeyword"] = 143] = "UnknownKeyword";
                    SyntaxKind[SyntaxKind["FromKeyword"] = 144] = "FromKeyword";
                    SyntaxKind[SyntaxKind["GlobalKeyword"] = 145] = "GlobalKeyword";
                    SyntaxKind[SyntaxKind["BigIntKeyword"] = 146] = "BigIntKeyword";
                    SyntaxKind[SyntaxKind["OfKeyword"] = 147] = "OfKeyword";
                    // Parse tree nodes
                    // Names
                    SyntaxKind[SyntaxKind["QualifiedName"] = 148] = "QualifiedName";
                    SyntaxKind[SyntaxKind["ComputedPropertyName"] = 149] = "ComputedPropertyName";
                    // Signature elements
                    SyntaxKind[SyntaxKind["TypeParameter"] = 150] = "TypeParameter";
                    SyntaxKind[SyntaxKind["Parameter"] = 151] = "Parameter";
                    SyntaxKind[SyntaxKind["Decorator"] = 152] = "Decorator";
                    // TypeMember
                    SyntaxKind[SyntaxKind["PropertySignature"] = 153] = "PropertySignature";
                    SyntaxKind[SyntaxKind["PropertyDeclaration"] = 154] = "PropertyDeclaration";
                    SyntaxKind[SyntaxKind["MethodSignature"] = 155] = "MethodSignature";
                    SyntaxKind[SyntaxKind["MethodDeclaration"] = 156] = "MethodDeclaration";
                    SyntaxKind[SyntaxKind["Constructor"] = 157] = "Constructor";
                    SyntaxKind[SyntaxKind["GetAccessor"] = 158] = "GetAccessor";
                    SyntaxKind[SyntaxKind["SetAccessor"] = 159] = "SetAccessor";
                    SyntaxKind[SyntaxKind["CallSignature"] = 160] = "CallSignature";
                    SyntaxKind[SyntaxKind["ConstructSignature"] = 161] = "ConstructSignature";
                    SyntaxKind[SyntaxKind["IndexSignature"] = 162] = "IndexSignature";
                    // Type
                    SyntaxKind[SyntaxKind["TypePredicate"] = 163] = "TypePredicate";
                    SyntaxKind[SyntaxKind["TypeReference"] = 164] = "TypeReference";
                    SyntaxKind[SyntaxKind["FunctionType"] = 165] = "FunctionType";
                    SyntaxKind[SyntaxKind["ConstructorType"] = 166] = "ConstructorType";
                    SyntaxKind[SyntaxKind["TypeQuery"] = 167] = "TypeQuery";
                    SyntaxKind[SyntaxKind["TypeLiteral"] = 168] = "TypeLiteral";
                    SyntaxKind[SyntaxKind["ArrayType"] = 169] = "ArrayType";
                    SyntaxKind[SyntaxKind["TupleType"] = 170] = "TupleType";
                    SyntaxKind[SyntaxKind["OptionalType"] = 171] = "OptionalType";
                    SyntaxKind[SyntaxKind["RestType"] = 172] = "RestType";
                    SyntaxKind[SyntaxKind["UnionType"] = 173] = "UnionType";
                    SyntaxKind[SyntaxKind["IntersectionType"] = 174] = "IntersectionType";
                    SyntaxKind[SyntaxKind["ConditionalType"] = 175] = "ConditionalType";
                    SyntaxKind[SyntaxKind["InferType"] = 176] = "InferType";
                    SyntaxKind[SyntaxKind["ParenthesizedType"] = 177] = "ParenthesizedType";
                    SyntaxKind[SyntaxKind["ThisType"] = 178] = "ThisType";
                    SyntaxKind[SyntaxKind["TypeOperator"] = 179] = "TypeOperator";
                    SyntaxKind[SyntaxKind["IndexedAccessType"] = 180] = "IndexedAccessType";
                    SyntaxKind[SyntaxKind["MappedType"] = 181] = "MappedType";
                    SyntaxKind[SyntaxKind["LiteralType"] = 182] = "LiteralType";
                    SyntaxKind[SyntaxKind["ImportType"] = 183] = "ImportType";
                    // Binding patterns
                    SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 184] = "ObjectBindingPattern";
                    SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 185] = "ArrayBindingPattern";
                    SyntaxKind[SyntaxKind["BindingElement"] = 186] = "BindingElement";
                    // Expression
                    SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 187] = "ArrayLiteralExpression";
                    SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 188] = "ObjectLiteralExpression";
                    SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 189] = "PropertyAccessExpression";
                    SyntaxKind[SyntaxKind["ElementAccessExpression"] = 190] = "ElementAccessExpression";
                    SyntaxKind[SyntaxKind["CallExpression"] = 191] = "CallExpression";
                    SyntaxKind[SyntaxKind["NewExpression"] = 192] = "NewExpression";
                    SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 193] = "TaggedTemplateExpression";
                    SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 194] = "TypeAssertionExpression";
                    SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 195] = "ParenthesizedExpression";
                    SyntaxKind[SyntaxKind["FunctionExpression"] = 196] = "FunctionExpression";
                    SyntaxKind[SyntaxKind["ArrowFunction"] = 197] = "ArrowFunction";
                    SyntaxKind[SyntaxKind["DeleteExpression"] = 198] = "DeleteExpression";
                    SyntaxKind[SyntaxKind["TypeOfExpression"] = 199] = "TypeOfExpression";
                    SyntaxKind[SyntaxKind["VoidExpression"] = 200] = "VoidExpression";
                    SyntaxKind[SyntaxKind["AwaitExpression"] = 201] = "AwaitExpression";
                    SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 202] = "PrefixUnaryExpression";
                    SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 203] = "PostfixUnaryExpression";
                    SyntaxKind[SyntaxKind["BinaryExpression"] = 204] = "BinaryExpression";
                    SyntaxKind[SyntaxKind["ConditionalExpression"] = 205] = "ConditionalExpression";
                    SyntaxKind[SyntaxKind["TemplateExpression"] = 206] = "TemplateExpression";
                    SyntaxKind[SyntaxKind["YieldExpression"] = 207] = "YieldExpression";
                    SyntaxKind[SyntaxKind["SpreadElement"] = 208] = "SpreadElement";
                    SyntaxKind[SyntaxKind["ClassExpression"] = 209] = "ClassExpression";
                    SyntaxKind[SyntaxKind["OmittedExpression"] = 210] = "OmittedExpression";
                    SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 211] = "ExpressionWithTypeArguments";
                    SyntaxKind[SyntaxKind["AsExpression"] = 212] = "AsExpression";
                    SyntaxKind[SyntaxKind["NonNullExpression"] = 213] = "NonNullExpression";
                    SyntaxKind[SyntaxKind["MetaProperty"] = 214] = "MetaProperty";
                    SyntaxKind[SyntaxKind["SyntheticExpression"] = 215] = "SyntheticExpression";
                    // Misc
                    SyntaxKind[SyntaxKind["TemplateSpan"] = 216] = "TemplateSpan";
                    SyntaxKind[SyntaxKind["SemicolonClassElement"] = 217] = "SemicolonClassElement";
                    // Element
                    SyntaxKind[SyntaxKind["Block"] = 218] = "Block";
                    SyntaxKind[SyntaxKind["VariableStatement"] = 219] = "VariableStatement";
                    SyntaxKind[SyntaxKind["EmptyStatement"] = 220] = "EmptyStatement";
                    SyntaxKind[SyntaxKind["ExpressionStatement"] = 221] = "ExpressionStatement";
                    SyntaxKind[SyntaxKind["IfStatement"] = 222] = "IfStatement";
                    SyntaxKind[SyntaxKind["DoStatement"] = 223] = "DoStatement";
                    SyntaxKind[SyntaxKind["WhileStatement"] = 224] = "WhileStatement";
                    SyntaxKind[SyntaxKind["ForStatement"] = 225] = "ForStatement";
                    SyntaxKind[SyntaxKind["ForInStatement"] = 226] = "ForInStatement";
                    SyntaxKind[SyntaxKind["ForOfStatement"] = 227] = "ForOfStatement";
                    SyntaxKind[SyntaxKind["ContinueStatement"] = 228] = "ContinueStatement";
                    SyntaxKind[SyntaxKind["BreakStatement"] = 229] = "BreakStatement";
                    SyntaxKind[SyntaxKind["ReturnStatement"] = 230] = "ReturnStatement";
                    SyntaxKind[SyntaxKind["WithStatement"] = 231] = "WithStatement";
                    SyntaxKind[SyntaxKind["SwitchStatement"] = 232] = "SwitchStatement";
                    SyntaxKind[SyntaxKind["LabeledStatement"] = 233] = "LabeledStatement";
                    SyntaxKind[SyntaxKind["ThrowStatement"] = 234] = "ThrowStatement";
                    SyntaxKind[SyntaxKind["TryStatement"] = 235] = "TryStatement";
                    SyntaxKind[SyntaxKind["DebuggerStatement"] = 236] = "DebuggerStatement";
                    SyntaxKind[SyntaxKind["VariableDeclaration"] = 237] = "VariableDeclaration";
                    SyntaxKind[SyntaxKind["VariableDeclarationList"] = 238] = "VariableDeclarationList";
                    SyntaxKind[SyntaxKind["FunctionDeclaration"] = 239] = "FunctionDeclaration";
                    SyntaxKind[SyntaxKind["ClassDeclaration"] = 240] = "ClassDeclaration";
                    SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 241] = "InterfaceDeclaration";
                    SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 242] = "TypeAliasDeclaration";
                    SyntaxKind[SyntaxKind["EnumDeclaration"] = 243] = "EnumDeclaration";
                    SyntaxKind[SyntaxKind["ModuleDeclaration"] = 244] = "ModuleDeclaration";
                    SyntaxKind[SyntaxKind["ModuleBlock"] = 245] = "ModuleBlock";
                    SyntaxKind[SyntaxKind["CaseBlock"] = 246] = "CaseBlock";
                    SyntaxKind[SyntaxKind["NamespaceExportDeclaration"] = 247] = "NamespaceExportDeclaration";
                    SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 248] = "ImportEqualsDeclaration";
                    SyntaxKind[SyntaxKind["ImportDeclaration"] = 249] = "ImportDeclaration";
                    SyntaxKind[SyntaxKind["ImportClause"] = 250] = "ImportClause";
                    SyntaxKind[SyntaxKind["NamespaceImport"] = 251] = "NamespaceImport";
                    SyntaxKind[SyntaxKind["NamedImports"] = 252] = "NamedImports";
                    SyntaxKind[SyntaxKind["ImportSpecifier"] = 253] = "ImportSpecifier";
                    SyntaxKind[SyntaxKind["ExportAssignment"] = 254] = "ExportAssignment";
                    SyntaxKind[SyntaxKind["ExportDeclaration"] = 255] = "ExportDeclaration";
                    SyntaxKind[SyntaxKind["NamedExports"] = 256] = "NamedExports";
                    SyntaxKind[SyntaxKind["ExportSpecifier"] = 257] = "ExportSpecifier";
                    SyntaxKind[SyntaxKind["MissingDeclaration"] = 258] = "MissingDeclaration";
                    // Module references
                    SyntaxKind[SyntaxKind["ExternalModuleReference"] = 259] = "ExternalModuleReference";
                    // JSX
                    SyntaxKind[SyntaxKind["JsxElement"] = 260] = "JsxElement";
                    SyntaxKind[SyntaxKind["JsxSelfClosingElement"] = 261] = "JsxSelfClosingElement";
                    SyntaxKind[SyntaxKind["JsxOpeningElement"] = 262] = "JsxOpeningElement";
                    SyntaxKind[SyntaxKind["JsxClosingElement"] = 263] = "JsxClosingElement";
                    SyntaxKind[SyntaxKind["JsxFragment"] = 264] = "JsxFragment";
                    SyntaxKind[SyntaxKind["JsxOpeningFragment"] = 265] = "JsxOpeningFragment";
                    SyntaxKind[SyntaxKind["JsxClosingFragment"] = 266] = "JsxClosingFragment";
                    SyntaxKind[SyntaxKind["JsxAttribute"] = 267] = "JsxAttribute";
                    SyntaxKind[SyntaxKind["JsxAttributes"] = 268] = "JsxAttributes";
                    SyntaxKind[SyntaxKind["JsxSpreadAttribute"] = 269] = "JsxSpreadAttribute";
                    SyntaxKind[SyntaxKind["JsxExpression"] = 270] = "JsxExpression";
                    // Clauses
                    SyntaxKind[SyntaxKind["CaseClause"] = 271] = "CaseClause";
                    SyntaxKind[SyntaxKind["DefaultClause"] = 272] = "DefaultClause";
                    SyntaxKind[SyntaxKind["HeritageClause"] = 273] = "HeritageClause";
                    SyntaxKind[SyntaxKind["CatchClause"] = 274] = "CatchClause";
                    // Property assignments
                    SyntaxKind[SyntaxKind["PropertyAssignment"] = 275] = "PropertyAssignment";
                    SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 276] = "ShorthandPropertyAssignment";
                    SyntaxKind[SyntaxKind["SpreadAssignment"] = 277] = "SpreadAssignment";
                    // Enum
                    SyntaxKind[SyntaxKind["EnumMember"] = 278] = "EnumMember";
                    // Unparsed
                    SyntaxKind[SyntaxKind["UnparsedPrologue"] = 279] = "UnparsedPrologue";
                    SyntaxKind[SyntaxKind["UnparsedPrepend"] = 280] = "UnparsedPrepend";
                    SyntaxKind[SyntaxKind["UnparsedText"] = 281] = "UnparsedText";
                    SyntaxKind[SyntaxKind["UnparsedInternalText"] = 282] = "UnparsedInternalText";
                    SyntaxKind[SyntaxKind["UnparsedSyntheticReference"] = 283] = "UnparsedSyntheticReference";
                    // Top-level nodes
                    SyntaxKind[SyntaxKind["SourceFile"] = 284] = "SourceFile";
                    SyntaxKind[SyntaxKind["Bundle"] = 285] = "Bundle";
                    SyntaxKind[SyntaxKind["UnparsedSource"] = 286] = "UnparsedSource";
                    SyntaxKind[SyntaxKind["InputFiles"] = 287] = "InputFiles";
                    // JSDoc nodes
                    SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 288] = "JSDocTypeExpression";
                    // The * type
                    SyntaxKind[SyntaxKind["JSDocAllType"] = 289] = "JSDocAllType";
                    // The ? type
                    SyntaxKind[SyntaxKind["JSDocUnknownType"] = 290] = "JSDocUnknownType";
                    SyntaxKind[SyntaxKind["JSDocNullableType"] = 291] = "JSDocNullableType";
                    SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 292] = "JSDocNonNullableType";
                    SyntaxKind[SyntaxKind["JSDocOptionalType"] = 293] = "JSDocOptionalType";
                    SyntaxKind[SyntaxKind["JSDocFunctionType"] = 294] = "JSDocFunctionType";
                    SyntaxKind[SyntaxKind["JSDocVariadicType"] = 295] = "JSDocVariadicType";
                    SyntaxKind[SyntaxKind["JSDocComment"] = 296] = "JSDocComment";
                    SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 297] = "JSDocTypeLiteral";
                    SyntaxKind[SyntaxKind["JSDocSignature"] = 298] = "JSDocSignature";
                    SyntaxKind[SyntaxKind["JSDocTag"] = 299] = "JSDocTag";
                    SyntaxKind[SyntaxKind["JSDocAugmentsTag"] = 300] = "JSDocAugmentsTag";
                    SyntaxKind[SyntaxKind["JSDocClassTag"] = 301] = "JSDocClassTag";
                    SyntaxKind[SyntaxKind["JSDocCallbackTag"] = 302] = "JSDocCallbackTag";
                    SyntaxKind[SyntaxKind["JSDocEnumTag"] = 303] = "JSDocEnumTag";
                    SyntaxKind[SyntaxKind["JSDocParameterTag"] = 304] = "JSDocParameterTag";
                    SyntaxKind[SyntaxKind["JSDocReturnTag"] = 305] = "JSDocReturnTag";
                    SyntaxKind[SyntaxKind["JSDocThisTag"] = 306] = "JSDocThisTag";
                    SyntaxKind[SyntaxKind["JSDocTypeTag"] = 307] = "JSDocTypeTag";
                    SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 308] = "JSDocTemplateTag";
                    SyntaxKind[SyntaxKind["JSDocTypedefTag"] = 309] = "JSDocTypedefTag";
                    SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 310] = "JSDocPropertyTag";
                    // Synthesized list
                    SyntaxKind[SyntaxKind["SyntaxList"] = 311] = "SyntaxList";
                    // Transformation nodes
                    SyntaxKind[SyntaxKind["NotEmittedStatement"] = 312] = "NotEmittedStatement";
                    SyntaxKind[SyntaxKind["PartiallyEmittedExpression"] = 313] = "PartiallyEmittedExpression";
                    SyntaxKind[SyntaxKind["CommaListExpression"] = 314] = "CommaListExpression";
                    SyntaxKind[SyntaxKind["MergeDeclarationMarker"] = 315] = "MergeDeclarationMarker";
                    SyntaxKind[SyntaxKind["EndOfDeclarationMarker"] = 316] = "EndOfDeclarationMarker";
                    // Enum value count
                    SyntaxKind[SyntaxKind["Count"] = 317] = "Count";
                    // Markers
                    SyntaxKind[SyntaxKind["FirstAssignment"] = 59] = "FirstAssignment";
                    SyntaxKind[SyntaxKind["LastAssignment"] = 71] = "LastAssignment";
                    SyntaxKind[SyntaxKind["FirstCompoundAssignment"] = 60] = "FirstCompoundAssignment";
                    SyntaxKind[SyntaxKind["LastCompoundAssignment"] = 71] = "LastCompoundAssignment";
                    SyntaxKind[SyntaxKind["FirstReservedWord"] = 73] = "FirstReservedWord";
                    SyntaxKind[SyntaxKind["LastReservedWord"] = 108] = "LastReservedWord";
                    SyntaxKind[SyntaxKind["FirstKeyword"] = 73] = "FirstKeyword";
                    SyntaxKind[SyntaxKind["LastKeyword"] = 147] = "LastKeyword";
                    SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 109] = "FirstFutureReservedWord";
                    SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 117] = "LastFutureReservedWord";
                    SyntaxKind[SyntaxKind["FirstTypeNode"] = 163] = "FirstTypeNode";
                    SyntaxKind[SyntaxKind["LastTypeNode"] = 183] = "LastTypeNode";
                    SyntaxKind[SyntaxKind["FirstPunctuation"] = 18] = "FirstPunctuation";
                    SyntaxKind[SyntaxKind["LastPunctuation"] = 71] = "LastPunctuation";
                    SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken";
                    SyntaxKind[SyntaxKind["LastToken"] = 147] = "LastToken";
                    SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken";
                    SyntaxKind[SyntaxKind["LastTriviaToken"] = 7] = "LastTriviaToken";
                    SyntaxKind[SyntaxKind["FirstLiteralToken"] = 8] = "FirstLiteralToken";
                    SyntaxKind[SyntaxKind["LastLiteralToken"] = 14] = "LastLiteralToken";
                    SyntaxKind[SyntaxKind["FirstTemplateToken"] = 14] = "FirstTemplateToken";
                    SyntaxKind[SyntaxKind["LastTemplateToken"] = 17] = "LastTemplateToken";
                    SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 28] = "FirstBinaryOperator";
                    SyntaxKind[SyntaxKind["LastBinaryOperator"] = 71] = "LastBinaryOperator";
                    SyntaxKind[SyntaxKind["FirstNode"] = 148] = "FirstNode";
                    SyntaxKind[SyntaxKind["FirstJSDocNode"] = 288] = "FirstJSDocNode";
                    SyntaxKind[SyntaxKind["LastJSDocNode"] = 310] = "LastJSDocNode";
                    SyntaxKind[SyntaxKind["FirstJSDocTagNode"] = 299] = "FirstJSDocTagNode";
                    SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 310] = "LastJSDocTagNode";
                    /* @internal */ SyntaxKind[SyntaxKind["FirstContextualKeyword"] = 118] = "FirstContextualKeyword";
                    /* @internal */ SyntaxKind[SyntaxKind["LastContextualKeyword"] = 147] = "LastContextualKeyword";
                })(SyntaxKind = ts.SyntaxKind || (ts.SyntaxKind = {}));
                var NodeFlags;
                (function (NodeFlags) {
                    NodeFlags[NodeFlags["None"] = 0] = "None";
                    NodeFlags[NodeFlags["Let"] = 1] = "Let";
                    NodeFlags[NodeFlags["Const"] = 2] = "Const";
                    NodeFlags[NodeFlags["NestedNamespace"] = 4] = "NestedNamespace";
                    NodeFlags[NodeFlags["Synthesized"] = 8] = "Synthesized";
                    NodeFlags[NodeFlags["Namespace"] = 16] = "Namespace";
                    NodeFlags[NodeFlags["ExportContext"] = 32] = "ExportContext";
                    NodeFlags[NodeFlags["ContainsThis"] = 64] = "ContainsThis";
                    NodeFlags[NodeFlags["HasImplicitReturn"] = 128] = "HasImplicitReturn";
                    NodeFlags[NodeFlags["HasExplicitReturn"] = 256] = "HasExplicitReturn";
                    NodeFlags[NodeFlags["GlobalAugmentation"] = 512] = "GlobalAugmentation";
                    NodeFlags[NodeFlags["HasAsyncFunctions"] = 1024] = "HasAsyncFunctions";
                    NodeFlags[NodeFlags["DisallowInContext"] = 2048] = "DisallowInContext";
                    NodeFlags[NodeFlags["YieldContext"] = 4096] = "YieldContext";
                    NodeFlags[NodeFlags["DecoratorContext"] = 8192] = "DecoratorContext";
                    NodeFlags[NodeFlags["AwaitContext"] = 16384] = "AwaitContext";
                    NodeFlags[NodeFlags["ThisNodeHasError"] = 32768] = "ThisNodeHasError";
                    NodeFlags[NodeFlags["JavaScriptFile"] = 65536] = "JavaScriptFile";
                    NodeFlags[NodeFlags["ThisNodeOrAnySubNodesHasError"] = 131072] = "ThisNodeOrAnySubNodesHasError";
                    NodeFlags[NodeFlags["HasAggregatedChildData"] = 262144] = "HasAggregatedChildData";
                    // These flags will be set when the parser encounters a dynamic import expression or 'import.meta' to avoid
                    // walking the tree if the flags are not set. However, these flags are just a approximation
                    // (hence why it's named "PossiblyContainsDynamicImport") because once set, the flags never get cleared.
                    // During editing, if a dynamic import is removed, incremental parsing will *NOT* clear this flag.
                    // This means that the tree will always be traversed during module resolution, or when looking for external module indicators.
                    // However, the removal operation should not occur often and in the case of the
                    // removal, it is likely that users will add the import anyway.
                    // The advantage of this approach is its simplicity. For the case of batch compilation,
                    // we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.
                    /* @internal */ NodeFlags[NodeFlags["PossiblyContainsDynamicImport"] = 524288] = "PossiblyContainsDynamicImport";
                    /* @internal */ NodeFlags[NodeFlags["PossiblyContainsImportMeta"] = 1048576] = "PossiblyContainsImportMeta";
                    NodeFlags[NodeFlags["JSDoc"] = 2097152] = "JSDoc";
                    /* @internal */ NodeFlags[NodeFlags["Ambient"] = 4194304] = "Ambient";
                    /* @internal */ NodeFlags[NodeFlags["InWithStatement"] = 8388608] = "InWithStatement";
                    NodeFlags[NodeFlags["JsonFile"] = 16777216] = "JsonFile";
                    NodeFlags[NodeFlags["BlockScoped"] = 3] = "BlockScoped";
                    NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 384] = "ReachabilityCheckFlags";
                    NodeFlags[NodeFlags["ReachabilityAndEmitFlags"] = 1408] = "ReachabilityAndEmitFlags";
                    // Parsing context flags
                    NodeFlags[NodeFlags["ContextFlags"] = 12679168] = "ContextFlags";
                    // Exclude these flags when parsing a Type
                    NodeFlags[NodeFlags["TypeExcludesFlags"] = 20480] = "TypeExcludesFlags";
                    // Represents all flags that are potentially set once and
                    // never cleared on SourceFiles which get re-used in between incremental parses.
                    // See the comment above on `PossiblyContainsDynamicImport` and `PossiblyContainsImportMeta`.
                    /* @internal */ NodeFlags[NodeFlags["PermanentlySetIncrementalFlags"] = 1572864] = "PermanentlySetIncrementalFlags";
                })(NodeFlags = ts.NodeFlags || (ts.NodeFlags = {}));
                var ModifierFlags;
                (function (ModifierFlags) {
                    ModifierFlags[ModifierFlags["None"] = 0] = "None";
                    ModifierFlags[ModifierFlags["Export"] = 1] = "Export";
                    ModifierFlags[ModifierFlags["Ambient"] = 2] = "Ambient";
                    ModifierFlags[ModifierFlags["Public"] = 4] = "Public";
                    ModifierFlags[ModifierFlags["Private"] = 8] = "Private";
                    ModifierFlags[ModifierFlags["Protected"] = 16] = "Protected";
                    ModifierFlags[ModifierFlags["Static"] = 32] = "Static";
                    ModifierFlags[ModifierFlags["Readonly"] = 64] = "Readonly";
                    ModifierFlags[ModifierFlags["Abstract"] = 128] = "Abstract";
                    ModifierFlags[ModifierFlags["Async"] = 256] = "Async";
                    ModifierFlags[ModifierFlags["Default"] = 512] = "Default";
                    ModifierFlags[ModifierFlags["Const"] = 2048] = "Const";
                    ModifierFlags[ModifierFlags["HasComputedFlags"] = 536870912] = "HasComputedFlags";
                    ModifierFlags[ModifierFlags["AccessibilityModifier"] = 28] = "AccessibilityModifier";
                    // Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.
                    ModifierFlags[ModifierFlags["ParameterPropertyModifier"] = 92] = "ParameterPropertyModifier";
                    ModifierFlags[ModifierFlags["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier";
                    ModifierFlags[ModifierFlags["TypeScriptModifier"] = 2270] = "TypeScriptModifier";
                    ModifierFlags[ModifierFlags["ExportDefault"] = 513] = "ExportDefault";
                    ModifierFlags[ModifierFlags["All"] = 3071] = "All";
                })(ModifierFlags = ts.ModifierFlags || (ts.ModifierFlags = {}));
                var JsxFlags;
                (function (JsxFlags) {
                    JsxFlags[JsxFlags["None"] = 0] = "None";
                    /** An element from a named property of the JSX.IntrinsicElements interface */
                    JsxFlags[JsxFlags["IntrinsicNamedElement"] = 1] = "IntrinsicNamedElement";
                    /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
                    JsxFlags[JsxFlags["IntrinsicIndexedElement"] = 2] = "IntrinsicIndexedElement";
                    JsxFlags[JsxFlags["IntrinsicElement"] = 3] = "IntrinsicElement";
                })(JsxFlags = ts.JsxFlags || (ts.JsxFlags = {}));
                /* @internal */
                var RelationComparisonResult;
                (function (RelationComparisonResult) {
                    RelationComparisonResult[RelationComparisonResult["Succeeded"] = 1] = "Succeeded";
                    RelationComparisonResult[RelationComparisonResult["Failed"] = 2] = "Failed";
                    RelationComparisonResult[RelationComparisonResult["FailedAndReported"] = 3] = "FailedAndReported";
                })(RelationComparisonResult = ts.RelationComparisonResult || (ts.RelationComparisonResult = {}));
                /*@internal*/
                var GeneratedIdentifierFlags;
                (function (GeneratedIdentifierFlags) {
                    // Kinds
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["None"] = 0] = "None";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["Auto"] = 1] = "Auto";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["Loop"] = 2] = "Loop";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["Unique"] = 3] = "Unique";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["Node"] = 4] = "Node";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["KindMask"] = 7] = "KindMask";
                    // Flags
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["ReservedInNestedScopes"] = 8] = "ReservedInNestedScopes";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["Optimistic"] = 16] = "Optimistic";
                    GeneratedIdentifierFlags[GeneratedIdentifierFlags["FileLevel"] = 32] = "FileLevel";
                })(GeneratedIdentifierFlags = ts.GeneratedIdentifierFlags || (ts.GeneratedIdentifierFlags = {}));
                var TokenFlags;
                (function (TokenFlags) {
                    TokenFlags[TokenFlags["None"] = 0] = "None";
                    /* @internal */
                    TokenFlags[TokenFlags["PrecedingLineBreak"] = 1] = "PrecedingLineBreak";
                    /* @internal */
                    TokenFlags[TokenFlags["PrecedingJSDocComment"] = 2] = "PrecedingJSDocComment";
                    /* @internal */
                    TokenFlags[TokenFlags["Unterminated"] = 4] = "Unterminated";
                    /* @internal */
                    TokenFlags[TokenFlags["ExtendedUnicodeEscape"] = 8] = "ExtendedUnicodeEscape";
                    TokenFlags[TokenFlags["Scientific"] = 16] = "Scientific";
                    TokenFlags[TokenFlags["Octal"] = 32] = "Octal";
                    TokenFlags[TokenFlags["HexSpecifier"] = 64] = "HexSpecifier";
                    TokenFlags[TokenFlags["BinarySpecifier"] = 128] = "BinarySpecifier";
                    TokenFlags[TokenFlags["OctalSpecifier"] = 256] = "OctalSpecifier";
                    /* @internal */
                    TokenFlags[TokenFlags["ContainsSeparator"] = 512] = "ContainsSeparator";
                    /* @internal */
                    TokenFlags[TokenFlags["BinaryOrOctalSpecifier"] = 384] = "BinaryOrOctalSpecifier";
                    /* @internal */
                    TokenFlags[TokenFlags["NumericLiteralFlags"] = 1008] = "NumericLiteralFlags";
                })(TokenFlags = ts.TokenFlags || (ts.TokenFlags = {}));
                var FlowFlags;
                (function (FlowFlags) {
                    FlowFlags[FlowFlags["Unreachable"] = 1] = "Unreachable";
                    FlowFlags[FlowFlags["Start"] = 2] = "Start";
                    FlowFlags[FlowFlags["BranchLabel"] = 4] = "BranchLabel";
                    FlowFlags[FlowFlags["LoopLabel"] = 8] = "LoopLabel";
                    FlowFlags[FlowFlags["Assignment"] = 16] = "Assignment";
                    FlowFlags[FlowFlags["TrueCondition"] = 32] = "TrueCondition";
                    FlowFlags[FlowFlags["FalseCondition"] = 64] = "FalseCondition";
                    FlowFlags[FlowFlags["SwitchClause"] = 128] = "SwitchClause";
                    FlowFlags[FlowFlags["ArrayMutation"] = 256] = "ArrayMutation";
                    FlowFlags[FlowFlags["Referenced"] = 512] = "Referenced";
                    FlowFlags[FlowFlags["Shared"] = 1024] = "Shared";
                    FlowFlags[FlowFlags["PreFinally"] = 2048] = "PreFinally";
                    FlowFlags[FlowFlags["AfterFinally"] = 4096] = "AfterFinally";
                    FlowFlags[FlowFlags["Label"] = 12] = "Label";
                    FlowFlags[FlowFlags["Condition"] = 96] = "Condition";
                })(FlowFlags = ts.FlowFlags || (ts.FlowFlags = {}));
                var OperationCanceledException = /** @class */ (function () {
                    function OperationCanceledException() {
                    }
                    return OperationCanceledException;
                }());
                ts.OperationCanceledException = OperationCanceledException;
                /* @internal */
                var StructureIsReused;
                (function (StructureIsReused) {
                    StructureIsReused[StructureIsReused["Not"] = 0] = "Not";
                    StructureIsReused[StructureIsReused["SafeModules"] = 1] = "SafeModules";
                    StructureIsReused[StructureIsReused["Completely"] = 2] = "Completely";
                })(StructureIsReused = ts.StructureIsReused || (ts.StructureIsReused = {}));
                /** Return code used by getEmitOutput function to indicate status of the function */
                var ExitStatus;
                (function (ExitStatus) {
                    // Compiler ran successfully.  Either this was a simple do-nothing compilation (for example,
                    // when -version or -help was provided, or this was a normal compilation, no diagnostics
                    // were produced, and all outputs were generated successfully.
                    ExitStatus[ExitStatus["Success"] = 0] = "Success";
                    // Diagnostics were produced and because of them no code was generated.
                    ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped";
                    // Diagnostics were produced and outputs were generated in spite of them.
                    ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated";
                })(ExitStatus = ts.ExitStatus || (ts.ExitStatus = {}));
                /* @internal */
                var UnionReduction;
                (function (UnionReduction) {
                    UnionReduction[UnionReduction["None"] = 0] = "None";
                    UnionReduction[UnionReduction["Literal"] = 1] = "Literal";
                    UnionReduction[UnionReduction["Subtype"] = 2] = "Subtype";
                })(UnionReduction = ts.UnionReduction || (ts.UnionReduction = {}));
                // NOTE: If modifying this enum, must modify `TypeFormatFlags` too!
                var NodeBuilderFlags;
                (function (NodeBuilderFlags) {
                    NodeBuilderFlags[NodeBuilderFlags["None"] = 0] = "None";
                    // Options
                    NodeBuilderFlags[NodeBuilderFlags["NoTruncation"] = 1] = "NoTruncation";
                    NodeBuilderFlags[NodeBuilderFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
                    NodeBuilderFlags[NodeBuilderFlags["GenerateNamesForShadowedTypeParams"] = 4] = "GenerateNamesForShadowedTypeParams";
                    NodeBuilderFlags[NodeBuilderFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback";
                    NodeBuilderFlags[NodeBuilderFlags["ForbidIndexedAccessSymbolReferences"] = 16] = "ForbidIndexedAccessSymbolReferences";
                    NodeBuilderFlags[NodeBuilderFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
                    NodeBuilderFlags[NodeBuilderFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
                    NodeBuilderFlags[NodeBuilderFlags["UseOnlyExternalAliasing"] = 128] = "UseOnlyExternalAliasing";
                    NodeBuilderFlags[NodeBuilderFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
                    NodeBuilderFlags[NodeBuilderFlags["WriteTypeParametersInQualifiedName"] = 512] = "WriteTypeParametersInQualifiedName";
                    NodeBuilderFlags[NodeBuilderFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
                    NodeBuilderFlags[NodeBuilderFlags["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral";
                    NodeBuilderFlags[NodeBuilderFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
                    NodeBuilderFlags[NodeBuilderFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
                    NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
                    // Error handling
                    NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral";
                    NodeBuilderFlags[NodeBuilderFlags["AllowQualifedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifedNameInPlaceOfIdentifier";
                    NodeBuilderFlags[NodeBuilderFlags["AllowAnonymousIdentifier"] = 131072] = "AllowAnonymousIdentifier";
                    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyUnionOrIntersection"] = 262144] = "AllowEmptyUnionOrIntersection";
                    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple";
                    NodeBuilderFlags[NodeBuilderFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
                    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType";
                    // Errors (cont.)
                    NodeBuilderFlags[NodeBuilderFlags["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
                    /* @internal */ NodeBuilderFlags[NodeBuilderFlags["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
                    NodeBuilderFlags[NodeBuilderFlags["IgnoreErrors"] = 70221824] = "IgnoreErrors";
                    // State
                    NodeBuilderFlags[NodeBuilderFlags["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral";
                    NodeBuilderFlags[NodeBuilderFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
                    NodeBuilderFlags[NodeBuilderFlags["InInitialEntityName"] = 16777216] = "InInitialEntityName";
                    NodeBuilderFlags[NodeBuilderFlags["InReverseMappedType"] = 33554432] = "InReverseMappedType";
                })(NodeBuilderFlags = ts.NodeBuilderFlags || (ts.NodeBuilderFlags = {}));
                // Ensure the shared flags between this and `NodeBuilderFlags` stay in alignment
                var TypeFormatFlags;
                (function (TypeFormatFlags) {
                    TypeFormatFlags[TypeFormatFlags["None"] = 0] = "None";
                    TypeFormatFlags[TypeFormatFlags["NoTruncation"] = 1] = "NoTruncation";
                    TypeFormatFlags[TypeFormatFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
                    // hole because there's a hole in node builder flags
                    TypeFormatFlags[TypeFormatFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback";
                    // hole because there's a hole in node builder flags
                    TypeFormatFlags[TypeFormatFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
                    TypeFormatFlags[TypeFormatFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
                    // hole because `UseOnlyExternalAliasing` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` instead
                    TypeFormatFlags[TypeFormatFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
                    // hole because `WriteTypeParametersInQualifiedName` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` for this instead
                    TypeFormatFlags[TypeFormatFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
                    TypeFormatFlags[TypeFormatFlags["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral";
                    TypeFormatFlags[TypeFormatFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
                    TypeFormatFlags[TypeFormatFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
                    TypeFormatFlags[TypeFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
                    // even though `T` can't be accessed in the current scope.
                    // Error Handling
                    TypeFormatFlags[TypeFormatFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
                    // TypeFormatFlags exclusive
                    TypeFormatFlags[TypeFormatFlags["AddUndefined"] = 131072] = "AddUndefined";
                    TypeFormatFlags[TypeFormatFlags["WriteArrowStyleSignature"] = 262144] = "WriteArrowStyleSignature";
                    // State
                    TypeFormatFlags[TypeFormatFlags["InArrayType"] = 524288] = "InArrayType";
                    TypeFormatFlags[TypeFormatFlags["InElementType"] = 2097152] = "InElementType";
                    TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument";
                    TypeFormatFlags[TypeFormatFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
                    /** @deprecated */ TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike";
                    TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 9469291] = "NodeBuilderFlagsMask";
                })(TypeFormatFlags = ts.TypeFormatFlags || (ts.TypeFormatFlags = {}));
                var SymbolFormatFlags;
                (function (SymbolFormatFlags) {
                    SymbolFormatFlags[SymbolFormatFlags["None"] = 0] = "None";
                    // Write symbols's type argument if it is instantiated symbol
                    // eg. class C<T> { p: T }   <-- Show p as C<T>.p here
                    //     var a: C<number>;
                    //     var p = a.p; <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
                    SymbolFormatFlags[SymbolFormatFlags["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments";
                    // Use only external alias information to get the symbol name in the given context
                    // eg.  module m { export class c { } } import x = m.c;
                    // When this flag is specified m.c will be used to refer to the class instead of alias symbol x
                    SymbolFormatFlags[SymbolFormatFlags["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing";
                    // Build symbol name using any nodes needed, instead of just components of an entity name
                    SymbolFormatFlags[SymbolFormatFlags["AllowAnyNodeKind"] = 4] = "AllowAnyNodeKind";
                    // Prefer aliases which are not directly visible
                    SymbolFormatFlags[SymbolFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 8] = "UseAliasDefinedOutsideCurrentScope";
                    // Skip building an accessible symbol chain
                    /* @internal */ SymbolFormatFlags[SymbolFormatFlags["DoNotIncludeSymbolChain"] = 16] = "DoNotIncludeSymbolChain";
                })(SymbolFormatFlags = ts.SymbolFormatFlags || (ts.SymbolFormatFlags = {}));
                /* @internal */
                var SymbolAccessibility;
                (function (SymbolAccessibility) {
                    SymbolAccessibility[SymbolAccessibility["Accessible"] = 0] = "Accessible";
                    SymbolAccessibility[SymbolAccessibility["NotAccessible"] = 1] = "NotAccessible";
                    SymbolAccessibility[SymbolAccessibility["CannotBeNamed"] = 2] = "CannotBeNamed";
                })(SymbolAccessibility = ts.SymbolAccessibility || (ts.SymbolAccessibility = {}));
                /* @internal */
                var SyntheticSymbolKind;
                (function (SyntheticSymbolKind) {
                    SyntheticSymbolKind[SyntheticSymbolKind["UnionOrIntersection"] = 0] = "UnionOrIntersection";
                    SyntheticSymbolKind[SyntheticSymbolKind["Spread"] = 1] = "Spread";
                })(SyntheticSymbolKind = ts.SyntheticSymbolKind || (ts.SyntheticSymbolKind = {}));
                var TypePredicateKind;
                (function (TypePredicateKind) {
                    TypePredicateKind[TypePredicateKind["This"] = 0] = "This";
                    TypePredicateKind[TypePredicateKind["Identifier"] = 1] = "Identifier";
                })(TypePredicateKind = ts.TypePredicateKind || (ts.TypePredicateKind = {}));
                /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator metadata */
                /* @internal */
                var TypeReferenceSerializationKind;
                (function (TypeReferenceSerializationKind) {
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["Unknown"] = 0] = "Unknown";
                    // should be emitted using a safe fallback.
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue";
                    // function that can be reached at runtime (e.g. a `class`
                    // declaration or a `var` declaration for the static side
                    // of a type, such as the global `Promise` type in lib.d.ts).
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["VoidNullableOrNeverType"] = 2] = "VoidNullableOrNeverType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["NumberLikeType"] = 3] = "NumberLikeType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["BigIntLikeType"] = 4] = "BigIntLikeType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 5] = "StringLikeType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 6] = "BooleanType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 7] = "ArrayLikeType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 8] = "ESSymbolType";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["Promise"] = 9] = "Promise";
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 10] = "TypeWithCallSignature";
                    // with call signatures.
                    TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 11] = "ObjectType";
                })(TypeReferenceSerializationKind = ts.TypeReferenceSerializationKind || (ts.TypeReferenceSerializationKind = {}));
                var SymbolFlags;
                (function (SymbolFlags) {
                    SymbolFlags[SymbolFlags["None"] = 0] = "None";
                    SymbolFlags[SymbolFlags["FunctionScopedVariable"] = 1] = "FunctionScopedVariable";
                    SymbolFlags[SymbolFlags["BlockScopedVariable"] = 2] = "BlockScopedVariable";
                    SymbolFlags[SymbolFlags["Property"] = 4] = "Property";
                    SymbolFlags[SymbolFlags["EnumMember"] = 8] = "EnumMember";
                    SymbolFlags[SymbolFlags["Function"] = 16] = "Function";
                    SymbolFlags[SymbolFlags["Class"] = 32] = "Class";
                    SymbolFlags[SymbolFlags["Interface"] = 64] = "Interface";
                    SymbolFlags[SymbolFlags["ConstEnum"] = 128] = "ConstEnum";
                    SymbolFlags[SymbolFlags["RegularEnum"] = 256] = "RegularEnum";
                    SymbolFlags[SymbolFlags["ValueModule"] = 512] = "ValueModule";
                    SymbolFlags[SymbolFlags["NamespaceModule"] = 1024] = "NamespaceModule";
                    SymbolFlags[SymbolFlags["TypeLiteral"] = 2048] = "TypeLiteral";
                    SymbolFlags[SymbolFlags["ObjectLiteral"] = 4096] = "ObjectLiteral";
                    SymbolFlags[SymbolFlags["Method"] = 8192] = "Method";
                    SymbolFlags[SymbolFlags["Constructor"] = 16384] = "Constructor";
                    SymbolFlags[SymbolFlags["GetAccessor"] = 32768] = "GetAccessor";
                    SymbolFlags[SymbolFlags["SetAccessor"] = 65536] = "SetAccessor";
                    SymbolFlags[SymbolFlags["Signature"] = 131072] = "Signature";
                    SymbolFlags[SymbolFlags["TypeParameter"] = 262144] = "TypeParameter";
                    SymbolFlags[SymbolFlags["TypeAlias"] = 524288] = "TypeAlias";
                    SymbolFlags[SymbolFlags["ExportValue"] = 1048576] = "ExportValue";
                    SymbolFlags[SymbolFlags["Alias"] = 2097152] = "Alias";
                    SymbolFlags[SymbolFlags["Prototype"] = 4194304] = "Prototype";
                    SymbolFlags[SymbolFlags["ExportStar"] = 8388608] = "ExportStar";
                    SymbolFlags[SymbolFlags["Optional"] = 16777216] = "Optional";
                    SymbolFlags[SymbolFlags["Transient"] = 33554432] = "Transient";
                    SymbolFlags[SymbolFlags["Assignment"] = 67108864] = "Assignment";
                    SymbolFlags[SymbolFlags["ModuleExports"] = 134217728] = "ModuleExports";
                    /* @internal */
                    SymbolFlags[SymbolFlags["All"] = 67108863] = "All";
                    SymbolFlags[SymbolFlags["Enum"] = 384] = "Enum";
                    SymbolFlags[SymbolFlags["Variable"] = 3] = "Variable";
                    SymbolFlags[SymbolFlags["Value"] = 67220415] = "Value";
                    SymbolFlags[SymbolFlags["Type"] = 67897832] = "Type";
                    SymbolFlags[SymbolFlags["Namespace"] = 1920] = "Namespace";
                    SymbolFlags[SymbolFlags["Module"] = 1536] = "Module";
                    SymbolFlags[SymbolFlags["Accessor"] = 98304] = "Accessor";
                    // Variables can be redeclared, but can not redeclare a block-scoped declaration with the
                    // same name, or any other value that is not a variable, e.g. ValueModule or Class
                    SymbolFlags[SymbolFlags["FunctionScopedVariableExcludes"] = 67220414] = "FunctionScopedVariableExcludes";
                    // Block-scoped declarations are not allowed to be re-declared
                    // they can not merge with anything in the value space
                    SymbolFlags[SymbolFlags["BlockScopedVariableExcludes"] = 67220415] = "BlockScopedVariableExcludes";
                    SymbolFlags[SymbolFlags["ParameterExcludes"] = 67220415] = "ParameterExcludes";
                    SymbolFlags[SymbolFlags["PropertyExcludes"] = 0] = "PropertyExcludes";
                    SymbolFlags[SymbolFlags["EnumMemberExcludes"] = 68008959] = "EnumMemberExcludes";
                    SymbolFlags[SymbolFlags["FunctionExcludes"] = 67219887] = "FunctionExcludes";
                    SymbolFlags[SymbolFlags["ClassExcludes"] = 68008383] = "ClassExcludes";
                    SymbolFlags[SymbolFlags["InterfaceExcludes"] = 67897736] = "InterfaceExcludes";
                    SymbolFlags[SymbolFlags["RegularEnumExcludes"] = 68008191] = "RegularEnumExcludes";
                    SymbolFlags[SymbolFlags["ConstEnumExcludes"] = 68008831] = "ConstEnumExcludes";
                    SymbolFlags[SymbolFlags["ValueModuleExcludes"] = 110735] = "ValueModuleExcludes";
                    SymbolFlags[SymbolFlags["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes";
                    SymbolFlags[SymbolFlags["MethodExcludes"] = 67212223] = "MethodExcludes";
                    SymbolFlags[SymbolFlags["GetAccessorExcludes"] = 67154879] = "GetAccessorExcludes";
                    SymbolFlags[SymbolFlags["SetAccessorExcludes"] = 67187647] = "SetAccessorExcludes";
                    SymbolFlags[SymbolFlags["TypeParameterExcludes"] = 67635688] = "TypeParameterExcludes";
                    SymbolFlags[SymbolFlags["TypeAliasExcludes"] = 67897832] = "TypeAliasExcludes";
                    SymbolFlags[SymbolFlags["AliasExcludes"] = 2097152] = "AliasExcludes";
                    SymbolFlags[SymbolFlags["ModuleMember"] = 2623475] = "ModuleMember";
                    SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal";
                    SymbolFlags[SymbolFlags["BlockScoped"] = 418] = "BlockScoped";
                    SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor";
                    SymbolFlags[SymbolFlags["ClassMember"] = 106500] = "ClassMember";
                    /* @internal */
                    // The set of things we consider semantically classifiable.  Used to speed up the LS during
                    // classification.
                    SymbolFlags[SymbolFlags["Classifiable"] = 2885600] = "Classifiable";
                    /* @internal */
                    SymbolFlags[SymbolFlags["LateBindingContainer"] = 6240] = "LateBindingContainer";
                })(SymbolFlags = ts.SymbolFlags || (ts.SymbolFlags = {}));
                /* @internal */
                var EnumKind;
                (function (EnumKind) {
                    EnumKind[EnumKind["Numeric"] = 0] = "Numeric";
                    EnumKind[EnumKind["Literal"] = 1] = "Literal"; // Literal enum (each member has a TypeFlags.EnumLiteral type)
                })(EnumKind = ts.EnumKind || (ts.EnumKind = {}));
                /* @internal */
                var CheckFlags;
                (function (CheckFlags) {
                    CheckFlags[CheckFlags["Instantiated"] = 1] = "Instantiated";
                    CheckFlags[CheckFlags["SyntheticProperty"] = 2] = "SyntheticProperty";
                    CheckFlags[CheckFlags["SyntheticMethod"] = 4] = "SyntheticMethod";
                    CheckFlags[CheckFlags["Readonly"] = 8] = "Readonly";
                    CheckFlags[CheckFlags["Partial"] = 16] = "Partial";
                    CheckFlags[CheckFlags["HasNonUniformType"] = 32] = "HasNonUniformType";
                    CheckFlags[CheckFlags["HasLiteralType"] = 64] = "HasLiteralType";
                    CheckFlags[CheckFlags["ContainsPublic"] = 128] = "ContainsPublic";
                    CheckFlags[CheckFlags["ContainsProtected"] = 256] = "ContainsProtected";
                    CheckFlags[CheckFlags["ContainsPrivate"] = 512] = "ContainsPrivate";
                    CheckFlags[CheckFlags["ContainsStatic"] = 1024] = "ContainsStatic";
                    CheckFlags[CheckFlags["Late"] = 2048] = "Late";
                    CheckFlags[CheckFlags["ReverseMapped"] = 4096] = "ReverseMapped";
                    CheckFlags[CheckFlags["OptionalParameter"] = 8192] = "OptionalParameter";
                    CheckFlags[CheckFlags["RestParameter"] = 16384] = "RestParameter";
                    CheckFlags[CheckFlags["Synthetic"] = 6] = "Synthetic";
                    CheckFlags[CheckFlags["Discriminant"] = 96] = "Discriminant";
                })(CheckFlags = ts.CheckFlags || (ts.CheckFlags = {}));
                var InternalSymbolName;
                (function (InternalSymbolName) {
                    InternalSymbolName["Call"] = "__call";
                    InternalSymbolName["Constructor"] = "__constructor";
                    InternalSymbolName["New"] = "__new";
                    InternalSymbolName["Index"] = "__index";
                    InternalSymbolName["ExportStar"] = "__export";
                    InternalSymbolName["Global"] = "__global";
                    InternalSymbolName["Missing"] = "__missing";
                    InternalSymbolName["Type"] = "__type";
                    InternalSymbolName["Object"] = "__object";
                    InternalSymbolName["JSXAttributes"] = "__jsxAttributes";
                    InternalSymbolName["Class"] = "__class";
                    InternalSymbolName["Function"] = "__function";
                    InternalSymbolName["Computed"] = "__computed";
                    InternalSymbolName["Resolving"] = "__resolving__";
                    InternalSymbolName["ExportEquals"] = "export=";
                    InternalSymbolName["Default"] = "default";
                    InternalSymbolName["This"] = "this";
                })(InternalSymbolName = ts.InternalSymbolName || (ts.InternalSymbolName = {}));
                /* @internal */
                var NodeCheckFlags;
                (function (NodeCheckFlags) {
                    NodeCheckFlags[NodeCheckFlags["TypeChecked"] = 1] = "TypeChecked";
                    NodeCheckFlags[NodeCheckFlags["LexicalThis"] = 2] = "LexicalThis";
                    NodeCheckFlags[NodeCheckFlags["CaptureThis"] = 4] = "CaptureThis";
                    NodeCheckFlags[NodeCheckFlags["CaptureNewTarget"] = 8] = "CaptureNewTarget";
                    NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance";
                    NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic";
                    NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
                    NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuper"] = 2048] = "AsyncMethodWithSuper";
                    NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuperBinding"] = 4096] = "AsyncMethodWithSuperBinding";
                    NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
                    NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
                    NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
                    NodeCheckFlags[NodeCheckFlags["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding";
                    NodeCheckFlags[NodeCheckFlags["ContainsCapturedBlockScopeBinding"] = 131072] = "ContainsCapturedBlockScopeBinding";
                    NodeCheckFlags[NodeCheckFlags["CapturedBlockScopedBinding"] = 262144] = "CapturedBlockScopedBinding";
                    NodeCheckFlags[NodeCheckFlags["BlockScopedBindingInLoop"] = 524288] = "BlockScopedBindingInLoop";
                    NodeCheckFlags[NodeCheckFlags["ClassWithBodyScopedClassBinding"] = 1048576] = "ClassWithBodyScopedClassBinding";
                    NodeCheckFlags[NodeCheckFlags["BodyScopedClassBinding"] = 2097152] = "BodyScopedClassBinding";
                    NodeCheckFlags[NodeCheckFlags["NeedsLoopOutParameter"] = 4194304] = "NeedsLoopOutParameter";
                    NodeCheckFlags[NodeCheckFlags["AssignmentsMarked"] = 8388608] = "AssignmentsMarked";
                    NodeCheckFlags[NodeCheckFlags["ClassWithConstructorReference"] = 16777216] = "ClassWithConstructorReference";
                    NodeCheckFlags[NodeCheckFlags["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass";
                })(NodeCheckFlags = ts.NodeCheckFlags || (ts.NodeCheckFlags = {}));
                var TypeFlags;
                (function (TypeFlags) {
                    TypeFlags[TypeFlags["Any"] = 1] = "Any";
                    TypeFlags[TypeFlags["Unknown"] = 2] = "Unknown";
                    TypeFlags[TypeFlags["String"] = 4] = "String";
                    TypeFlags[TypeFlags["Number"] = 8] = "Number";
                    TypeFlags[TypeFlags["Boolean"] = 16] = "Boolean";
                    TypeFlags[TypeFlags["Enum"] = 32] = "Enum";
                    TypeFlags[TypeFlags["BigInt"] = 64] = "BigInt";
                    TypeFlags[TypeFlags["StringLiteral"] = 128] = "StringLiteral";
                    TypeFlags[TypeFlags["NumberLiteral"] = 256] = "NumberLiteral";
                    TypeFlags[TypeFlags["BooleanLiteral"] = 512] = "BooleanLiteral";
                    TypeFlags[TypeFlags["EnumLiteral"] = 1024] = "EnumLiteral";
                    TypeFlags[TypeFlags["BigIntLiteral"] = 2048] = "BigIntLiteral";
                    TypeFlags[TypeFlags["ESSymbol"] = 4096] = "ESSymbol";
                    TypeFlags[TypeFlags["UniqueESSymbol"] = 8192] = "UniqueESSymbol";
                    TypeFlags[TypeFlags["Void"] = 16384] = "Void";
                    TypeFlags[TypeFlags["Undefined"] = 32768] = "Undefined";
                    TypeFlags[TypeFlags["Null"] = 65536] = "Null";
                    TypeFlags[TypeFlags["Never"] = 131072] = "Never";
                    TypeFlags[TypeFlags["TypeParameter"] = 262144] = "TypeParameter";
                    TypeFlags[TypeFlags["Object"] = 524288] = "Object";
                    TypeFlags[TypeFlags["Union"] = 1048576] = "Union";
                    TypeFlags[TypeFlags["Intersection"] = 2097152] = "Intersection";
                    TypeFlags[TypeFlags["Index"] = 4194304] = "Index";
                    TypeFlags[TypeFlags["IndexedAccess"] = 8388608] = "IndexedAccess";
                    TypeFlags[TypeFlags["Conditional"] = 16777216] = "Conditional";
                    TypeFlags[TypeFlags["Substitution"] = 33554432] = "Substitution";
                    TypeFlags[TypeFlags["NonPrimitive"] = 67108864] = "NonPrimitive";
                    /* @internal */
                    TypeFlags[TypeFlags["AnyOrUnknown"] = 3] = "AnyOrUnknown";
                    /* @internal */
                    TypeFlags[TypeFlags["Nullable"] = 98304] = "Nullable";
                    TypeFlags[TypeFlags["Literal"] = 2944] = "Literal";
                    TypeFlags[TypeFlags["Unit"] = 109440] = "Unit";
                    TypeFlags[TypeFlags["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
                    /* @internal */
                    TypeFlags[TypeFlags["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique";
                    /* @internal */
                    TypeFlags[TypeFlags["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
                    TypeFlags[TypeFlags["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
                    /* @internal */
                    TypeFlags[TypeFlags["Intrinsic"] = 67359327] = "Intrinsic";
                    /* @internal */
                    TypeFlags[TypeFlags["Primitive"] = 131068] = "Primitive";
                    TypeFlags[TypeFlags["StringLike"] = 132] = "StringLike";
                    TypeFlags[TypeFlags["NumberLike"] = 296] = "NumberLike";
                    TypeFlags[TypeFlags["BigIntLike"] = 2112] = "BigIntLike";
                    TypeFlags[TypeFlags["BooleanLike"] = 528] = "BooleanLike";
                    TypeFlags[TypeFlags["EnumLike"] = 1056] = "EnumLike";
                    TypeFlags[TypeFlags["ESSymbolLike"] = 12288] = "ESSymbolLike";
                    TypeFlags[TypeFlags["VoidLike"] = 49152] = "VoidLike";
                    /* @internal */
                    TypeFlags[TypeFlags["DisjointDomains"] = 67238908] = "DisjointDomains";
                    TypeFlags[TypeFlags["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
                    TypeFlags[TypeFlags["StructuredType"] = 3670016] = "StructuredType";
                    TypeFlags[TypeFlags["TypeVariable"] = 8650752] = "TypeVariable";
                    TypeFlags[TypeFlags["InstantiableNonPrimitive"] = 58982400] = "InstantiableNonPrimitive";
                    TypeFlags[TypeFlags["InstantiablePrimitive"] = 4194304] = "InstantiablePrimitive";
                    TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";
                    TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";
                    /* @internal */
                    TypeFlags[TypeFlags["ObjectFlagsType"] = 3768320] = "ObjectFlagsType";
                    // 'Narrowable' types are types where narrowing actually narrows.
                    // This *should* be every type other than null, undefined, void, and never
                    TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";
                    TypeFlags[TypeFlags["NotUnionOrUnit"] = 67637251] = "NotUnionOrUnit";
                    /* @internal */
                    TypeFlags[TypeFlags["NotPrimitiveUnion"] = 66994211] = "NotPrimitiveUnion";
                    // The following flags are aggregated during union and intersection type construction
                    /* @internal */
                    TypeFlags[TypeFlags["IncludesMask"] = 1835007] = "IncludesMask";
                    // The following flags are used for different purposes during union and intersection type construction
                    /* @internal */
                    TypeFlags[TypeFlags["IncludesStructuredOrInstantiable"] = 262144] = "IncludesStructuredOrInstantiable";
                    /* @internal */
                    TypeFlags[TypeFlags["IncludesNonWideningType"] = 2097152] = "IncludesNonWideningType";
                    /* @internal */
                    TypeFlags[TypeFlags["IncludesWildcard"] = 4194304] = "IncludesWildcard";
                    /* @internal */
                    TypeFlags[TypeFlags["IncludesEmptyObject"] = 8388608] = "IncludesEmptyObject";
                    // The following flag is used for different purposes by maybeTypeOfKind
                    /* @internal */
                    TypeFlags[TypeFlags["GenericMappedType"] = 131072] = "GenericMappedType";
                })(TypeFlags = ts.TypeFlags || (ts.TypeFlags = {}));
                var ObjectFlags;
                (function (ObjectFlags) {
                    ObjectFlags[ObjectFlags["Class"] = 1] = "Class";
                    ObjectFlags[ObjectFlags["Interface"] = 2] = "Interface";
                    ObjectFlags[ObjectFlags["Reference"] = 4] = "Reference";
                    ObjectFlags[ObjectFlags["Tuple"] = 8] = "Tuple";
                    ObjectFlags[ObjectFlags["Anonymous"] = 16] = "Anonymous";
                    ObjectFlags[ObjectFlags["Mapped"] = 32] = "Mapped";
                    ObjectFlags[ObjectFlags["Instantiated"] = 64] = "Instantiated";
                    ObjectFlags[ObjectFlags["ObjectLiteral"] = 128] = "ObjectLiteral";
                    ObjectFlags[ObjectFlags["EvolvingArray"] = 256] = "EvolvingArray";
                    ObjectFlags[ObjectFlags["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties";
                    ObjectFlags[ObjectFlags["ContainsSpread"] = 1024] = "ContainsSpread";
                    ObjectFlags[ObjectFlags["ReverseMapped"] = 2048] = "ReverseMapped";
                    ObjectFlags[ObjectFlags["JsxAttributes"] = 4096] = "JsxAttributes";
                    ObjectFlags[ObjectFlags["MarkerType"] = 8192] = "MarkerType";
                    ObjectFlags[ObjectFlags["JSLiteral"] = 16384] = "JSLiteral";
                    ObjectFlags[ObjectFlags["FreshLiteral"] = 32768] = "FreshLiteral";
                    /* @internal */
                    ObjectFlags[ObjectFlags["PrimitiveUnion"] = 65536] = "PrimitiveUnion";
                    /* @internal */
                    ObjectFlags[ObjectFlags["ContainsWideningType"] = 131072] = "ContainsWideningType";
                    /* @internal */
                    ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";
                    /* @internal */
                    ObjectFlags[ObjectFlags["ContainsAnyFunctionType"] = 524288] = "ContainsAnyFunctionType";
                    ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";
                    /* @internal */
                    ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";
                    /* @internal */
                    ObjectFlags[ObjectFlags["PropagatingFlags"] = 917504] = "PropagatingFlags";
                })(ObjectFlags = ts.ObjectFlags || (ts.ObjectFlags = {}));
                /* @internal */
                var Variance;
                (function (Variance) {
                    Variance[Variance["Invariant"] = 0] = "Invariant";
                    Variance[Variance["Covariant"] = 1] = "Covariant";
                    Variance[Variance["Contravariant"] = 2] = "Contravariant";
                    Variance[Variance["Bivariant"] = 3] = "Bivariant";
                    Variance[Variance["Independent"] = 4] = "Independent";
                })(Variance = ts.Variance || (ts.Variance = {}));
                /* @internal */
                var JsxReferenceKind;
                (function (JsxReferenceKind) {
                    JsxReferenceKind[JsxReferenceKind["Component"] = 0] = "Component";
                    JsxReferenceKind[JsxReferenceKind["Function"] = 1] = "Function";
                    JsxReferenceKind[JsxReferenceKind["Mixed"] = 2] = "Mixed";
                })(JsxReferenceKind = ts.JsxReferenceKind || (ts.JsxReferenceKind = {}));
                var SignatureKind;
                (function (SignatureKind) {
                    SignatureKind[SignatureKind["Call"] = 0] = "Call";
                    SignatureKind[SignatureKind["Construct"] = 1] = "Construct";
                })(SignatureKind = ts.SignatureKind || (ts.SignatureKind = {}));
                var IndexKind;
                (function (IndexKind) {
                    IndexKind[IndexKind["String"] = 0] = "String";
                    IndexKind[IndexKind["Number"] = 1] = "Number";
                })(IndexKind = ts.IndexKind || (ts.IndexKind = {}));
                var InferencePriority;
                (function (InferencePriority) {
                    InferencePriority[InferencePriority["NakedTypeVariable"] = 1] = "NakedTypeVariable";
                    InferencePriority[InferencePriority["HomomorphicMappedType"] = 2] = "HomomorphicMappedType";
                    InferencePriority[InferencePriority["MappedTypeConstraint"] = 4] = "MappedTypeConstraint";
                    InferencePriority[InferencePriority["ReturnType"] = 8] = "ReturnType";
                    InferencePriority[InferencePriority["LiteralKeyof"] = 16] = "LiteralKeyof";
                    InferencePriority[InferencePriority["NoConstraints"] = 32] = "NoConstraints";
                    InferencePriority[InferencePriority["AlwaysStrict"] = 64] = "AlwaysStrict";
                    InferencePriority[InferencePriority["PriorityImpliesCombination"] = 28] = "PriorityImpliesCombination";
                })(InferencePriority = ts.InferencePriority || (ts.InferencePriority = {}));
                /* @internal */
                var InferenceFlags;
                (function (InferenceFlags) {
                    InferenceFlags[InferenceFlags["None"] = 0] = "None";
                    InferenceFlags[InferenceFlags["NoDefault"] = 1] = "NoDefault";
                    InferenceFlags[InferenceFlags["AnyDefault"] = 2] = "AnyDefault";
                    InferenceFlags[InferenceFlags["SkippedGenericFunction"] = 4] = "SkippedGenericFunction";
                })(InferenceFlags = ts.InferenceFlags || (ts.InferenceFlags = {}));
                /**
                 * Ternary values are defined such that
                 * x & y is False if either x or y is False.
                 * x & y is Maybe if either x or y is Maybe, but neither x or y is False.
                 * x & y is True if both x and y are True.
                 * x | y is False if both x and y are False.
                 * x | y is Maybe if either x or y is Maybe, but neither x or y is True.
                 * x | y is True if either x or y is True.
                 */
                /* @internal */
                var Ternary;
                (function (Ternary) {
                    Ternary[Ternary["False"] = 0] = "False";
                    Ternary[Ternary["Maybe"] = 1] = "Maybe";
                    Ternary[Ternary["True"] = -1] = "True";
                })(Ternary = ts.Ternary || (ts.Ternary = {}));
                /* @internal */
                var AssignmentDeclarationKind;
                (function (AssignmentDeclarationKind) {
                    AssignmentDeclarationKind[AssignmentDeclarationKind["None"] = 0] = "None";
                    /// exports.name = expr
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ExportsProperty"] = 1] = "ExportsProperty";
                    /// module.exports = expr
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ModuleExports"] = 2] = "ModuleExports";
                    /// className.prototype.name = expr
                    AssignmentDeclarationKind[AssignmentDeclarationKind["PrototypeProperty"] = 3] = "PrototypeProperty";
                    /// this.name = expr
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ThisProperty"] = 4] = "ThisProperty";
                    // F.name = expr
                    AssignmentDeclarationKind[AssignmentDeclarationKind["Property"] = 5] = "Property";
                    // F.prototype = { ... }
                    AssignmentDeclarationKind[AssignmentDeclarationKind["Prototype"] = 6] = "Prototype";
                    // Object.defineProperty(x, 'name', { value: any, writable?: boolean (false by default) });
                    // Object.defineProperty(x, 'name', { get: Function, set: Function });
                    // Object.defineProperty(x, 'name', { get: Function });
                    // Object.defineProperty(x, 'name', { set: Function });
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePropertyValue"] = 7] = "ObjectDefinePropertyValue";
                    // Object.defineProperty(exports || module.exports, 'name', ...);
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePropertyExports"] = 8] = "ObjectDefinePropertyExports";
                    // Object.defineProperty(Foo.prototype, 'name', ...);
                    AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePrototypeProperty"] = 9] = "ObjectDefinePrototypeProperty";
                })(AssignmentDeclarationKind = ts.AssignmentDeclarationKind || (ts.AssignmentDeclarationKind = {}));
                var DiagnosticCategory;
                (function (DiagnosticCategory) {
                    DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning";
                    DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";
                    DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion";
                    DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message";
                })(DiagnosticCategory = ts.DiagnosticCategory || (ts.DiagnosticCategory = {}));
                /* @internal */
                function diagnosticCategoryName(d, lowerCase) {
                    if (lowerCase === void 0) { lowerCase = true; }
                    var name = DiagnosticCategory[d.category];
                    return lowerCase ? name.toLowerCase() : name;
                }
                ts.diagnosticCategoryName = diagnosticCategoryName;
                var ModuleResolutionKind;
                (function (ModuleResolutionKind) {
                    ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";
                    ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";
                })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));
                var ModuleKind;
                (function (ModuleKind) {
                    ModuleKind[ModuleKind["None"] = 0] = "None";
                    ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS";
                    ModuleKind[ModuleKind["AMD"] = 2] = "AMD";
                    ModuleKind[ModuleKind["UMD"] = 3] = "UMD";
                    ModuleKind[ModuleKind["System"] = 4] = "System";
                    ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";
                    ModuleKind[ModuleKind["ESNext"] = 6] = "ESNext";
                })(ModuleKind = ts.ModuleKind || (ts.ModuleKind = {}));
                var JsxEmit;
                (function (JsxEmit) {
                    JsxEmit[JsxEmit["None"] = 0] = "None";
                    JsxEmit[JsxEmit["Preserve"] = 1] = "Preserve";
                    JsxEmit[JsxEmit["React"] = 2] = "React";
                    JsxEmit[JsxEmit["ReactNative"] = 3] = "ReactNative";
                })(JsxEmit = ts.JsxEmit || (ts.JsxEmit = {}));
                var NewLineKind;
                (function (NewLineKind) {
                    NewLineKind[NewLineKind["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed";
                    NewLineKind[NewLineKind["LineFeed"] = 1] = "LineFeed";
                })(NewLineKind = ts.NewLineKind || (ts.NewLineKind = {}));
                var ScriptKind;
                (function (ScriptKind) {
                    ScriptKind[ScriptKind["Unknown"] = 0] = "Unknown";
                    ScriptKind[ScriptKind["JS"] = 1] = "JS";
                    ScriptKind[ScriptKind["JSX"] = 2] = "JSX";
                    ScriptKind[ScriptKind["TS"] = 3] = "TS";
                    ScriptKind[ScriptKind["TSX"] = 4] = "TSX";
                    ScriptKind[ScriptKind["External"] = 5] = "External";
                    ScriptKind[ScriptKind["JSON"] = 6] = "JSON";
                    /**
                     * Used on extensions that doesn't define the ScriptKind but the content defines it.
                     * Deferred extensions are going to be included in all project contexts.
                     */
                    ScriptKind[ScriptKind["Deferred"] = 7] = "Deferred";
                })(ScriptKind = ts.ScriptKind || (ts.ScriptKind = {}));
                var ScriptTarget;
                (function (ScriptTarget) {
                    ScriptTarget[ScriptTarget["ES3"] = 0] = "ES3";
                    ScriptTarget[ScriptTarget["ES5"] = 1] = "ES5";
                    ScriptTarget[ScriptTarget["ES2015"] = 2] = "ES2015";
                    ScriptTarget[ScriptTarget["ES2016"] = 3] = "ES2016";
                    ScriptTarget[ScriptTarget["ES2017"] = 4] = "ES2017";
                    ScriptTarget[ScriptTarget["ES2018"] = 5] = "ES2018";
                    ScriptTarget[ScriptTarget["ES2019"] = 6] = "ES2019";
                    ScriptTarget[ScriptTarget["ESNext"] = 7] = "ESNext";
                    ScriptTarget[ScriptTarget["JSON"] = 100] = "JSON";
                    ScriptTarget[ScriptTarget["Latest"] = 7] = "Latest";
                })(ScriptTarget = ts.ScriptTarget || (ts.ScriptTarget = {}));
                var LanguageVariant;
                (function (LanguageVariant) {
                    LanguageVariant[LanguageVariant["Standard"] = 0] = "Standard";
                    LanguageVariant[LanguageVariant["JSX"] = 1] = "JSX";
                })(LanguageVariant = ts.LanguageVariant || (ts.LanguageVariant = {}));
                var WatchDirectoryFlags;
                (function (WatchDirectoryFlags) {
                    WatchDirectoryFlags[WatchDirectoryFlags["None"] = 0] = "None";
                    WatchDirectoryFlags[WatchDirectoryFlags["Recursive"] = 1] = "Recursive";
                })(WatchDirectoryFlags = ts.WatchDirectoryFlags || (ts.WatchDirectoryFlags = {}));
                /* @internal */
                var CharacterCodes;
                (function (CharacterCodes) {
                    CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
                    CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
                    CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
                    CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
                    CharacterCodes[CharacterCodes["lineSeparator"] = 8232] = "lineSeparator";
                    CharacterCodes[CharacterCodes["paragraphSeparator"] = 8233] = "paragraphSeparator";
                    CharacterCodes[CharacterCodes["nextLine"] = 133] = "nextLine";
                    // Unicode 3.0 space characters
                    CharacterCodes[CharacterCodes["space"] = 32] = "space";
                    CharacterCodes[CharacterCodes["nonBreakingSpace"] = 160] = "nonBreakingSpace";
                    CharacterCodes[CharacterCodes["enQuad"] = 8192] = "enQuad";
                    CharacterCodes[CharacterCodes["emQuad"] = 8193] = "emQuad";
                    CharacterCodes[CharacterCodes["enSpace"] = 8194] = "enSpace";
                    CharacterCodes[CharacterCodes["emSpace"] = 8195] = "emSpace";
                    CharacterCodes[CharacterCodes["threePerEmSpace"] = 8196] = "threePerEmSpace";
                    CharacterCodes[CharacterCodes["fourPerEmSpace"] = 8197] = "fourPerEmSpace";
                    CharacterCodes[CharacterCodes["sixPerEmSpace"] = 8198] = "sixPerEmSpace";
                    CharacterCodes[CharacterCodes["figureSpace"] = 8199] = "figureSpace";
                    CharacterCodes[CharacterCodes["punctuationSpace"] = 8200] = "punctuationSpace";
                    CharacterCodes[CharacterCodes["thinSpace"] = 8201] = "thinSpace";
                    CharacterCodes[CharacterCodes["hairSpace"] = 8202] = "hairSpace";
                    CharacterCodes[CharacterCodes["zeroWidthSpace"] = 8203] = "zeroWidthSpace";
                    CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace";
                    CharacterCodes[CharacterCodes["ideographicSpace"] = 12288] = "ideographicSpace";
                    CharacterCodes[CharacterCodes["mathematicalSpace"] = 8287] = "mathematicalSpace";
                    CharacterCodes[CharacterCodes["ogham"] = 5760] = "ogham";
                    CharacterCodes[CharacterCodes["_"] = 95] = "_";
                    CharacterCodes[CharacterCodes["$"] = 36] = "$";
                    CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
                    CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
                    CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
                    CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
                    CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
                    CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
                    CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
                    CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
                    CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
                    CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
                    CharacterCodes[CharacterCodes["a"] = 97] = "a";
                    CharacterCodes[CharacterCodes["b"] = 98] = "b";
                    CharacterCodes[CharacterCodes["c"] = 99] = "c";
                    CharacterCodes[CharacterCodes["d"] = 100] = "d";
                    CharacterCodes[CharacterCodes["e"] = 101] = "e";
                    CharacterCodes[CharacterCodes["f"] = 102] = "f";
                    CharacterCodes[CharacterCodes["g"] = 103] = "g";
                    CharacterCodes[CharacterCodes["h"] = 104] = "h";
                    CharacterCodes[CharacterCodes["i"] = 105] = "i";
                    CharacterCodes[CharacterCodes["j"] = 106] = "j";
                    CharacterCodes[CharacterCodes["k"] = 107] = "k";
                    CharacterCodes[CharacterCodes["l"] = 108] = "l";
                    CharacterCodes[CharacterCodes["m"] = 109] = "m";
                    CharacterCodes[CharacterCodes["n"] = 110] = "n";
                    CharacterCodes[CharacterCodes["o"] = 111] = "o";
                    CharacterCodes[CharacterCodes["p"] = 112] = "p";
                    CharacterCodes[CharacterCodes["q"] = 113] = "q";
                    CharacterCodes[CharacterCodes["r"] = 114] = "r";
                    CharacterCodes[CharacterCodes["s"] = 115] = "s";
                    CharacterCodes[CharacterCodes["t"] = 116] = "t";
                    CharacterCodes[CharacterCodes["u"] = 117] = "u";
                    CharacterCodes[CharacterCodes["v"] = 118] = "v";
                    CharacterCodes[CharacterCodes["w"] = 119] = "w";
                    CharacterCodes[CharacterCodes["x"] = 120] = "x";
                    CharacterCodes[CharacterCodes["y"] = 121] = "y";
                    CharacterCodes[CharacterCodes["z"] = 122] = "z";
                    CharacterCodes[CharacterCodes["A"] = 65] = "A";
                    CharacterCodes[CharacterCodes["B"] = 66] = "B";
                    CharacterCodes[CharacterCodes["C"] = 67] = "C";
                    CharacterCodes[CharacterCodes["D"] = 68] = "D";
                    CharacterCodes[CharacterCodes["E"] = 69] = "E";
                    CharacterCodes[CharacterCodes["F"] = 70] = "F";
                    CharacterCodes[CharacterCodes["G"] = 71] = "G";
                    CharacterCodes[CharacterCodes["H"] = 72] = "H";
                    CharacterCodes[CharacterCodes["I"] = 73] = "I";
                    CharacterCodes[CharacterCodes["J"] = 74] = "J";
                    CharacterCodes[CharacterCodes["K"] = 75] = "K";
                    CharacterCodes[CharacterCodes["L"] = 76] = "L";
                    CharacterCodes[CharacterCodes["M"] = 77] = "M";
                    CharacterCodes[CharacterCodes["N"] = 78] = "N";
                    CharacterCodes[CharacterCodes["O"] = 79] = "O";
                    CharacterCodes[CharacterCodes["P"] = 80] = "P";
                    CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
                    CharacterCodes[CharacterCodes["R"] = 82] = "R";
                    CharacterCodes[CharacterCodes["S"] = 83] = "S";
                    CharacterCodes[CharacterCodes["T"] = 84] = "T";
                    CharacterCodes[CharacterCodes["U"] = 85] = "U";
                    CharacterCodes[CharacterCodes["V"] = 86] = "V";
                    CharacterCodes[CharacterCodes["W"] = 87] = "W";
                    CharacterCodes[CharacterCodes["X"] = 88] = "X";
                    CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
                    CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
                    CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand";
                    CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
                    CharacterCodes[CharacterCodes["at"] = 64] = "at";
                    CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
                    CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick";
                    CharacterCodes[CharacterCodes["bar"] = 124] = "bar";
                    CharacterCodes[CharacterCodes["caret"] = 94] = "caret";
                    CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
                    CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
                    CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen";
                    CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
                    CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
                    CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
                    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
                    CharacterCodes[CharacterCodes["equals"] = 61] = "equals";
                    CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation";
                    CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan";
                    CharacterCodes[CharacterCodes["hash"] = 35] = "hash";
                    CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan";
                    CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
                    CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
                    CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
                    CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen";
                    CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
                    CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
                    CharacterCodes[CharacterCodes["question"] = 63] = "question";
                    CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon";
                    CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
                    CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
                    CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde";
                    CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace";
                    CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
                    CharacterCodes[CharacterCodes["byteOrderMark"] = 65279] = "byteOrderMark";
                    CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
                    CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab";
                })(CharacterCodes = ts.CharacterCodes || (ts.CharacterCodes = {}));
                var Extension;
                (function (Extension) {
                    Extension["Ts"] = ".ts";
                    Extension["Tsx"] = ".tsx";
                    Extension["Dts"] = ".d.ts";
                    Extension["Js"] = ".js";
                    Extension["Jsx"] = ".jsx";
                    Extension["Json"] = ".json";
                    Extension["TsBuildInfo"] = ".tsbuildinfo";
                })(Extension = ts.Extension || (ts.Extension = {}));
                /* @internal */
                var TransformFlags;
                (function (TransformFlags) {
                    TransformFlags[TransformFlags["None"] = 0] = "None";
                    // Facts
                    // - Flags used to indicate that a node or subtree contains syntax that requires transformation.
                    TransformFlags[TransformFlags["ContainsTypeScript"] = 1] = "ContainsTypeScript";
                    TransformFlags[TransformFlags["ContainsJsx"] = 2] = "ContainsJsx";
                    TransformFlags[TransformFlags["ContainsESNext"] = 4] = "ContainsESNext";
                    TransformFlags[TransformFlags["ContainsES2019"] = 8] = "ContainsES2019";
                    TransformFlags[TransformFlags["ContainsES2018"] = 16] = "ContainsES2018";
                    TransformFlags[TransformFlags["ContainsES2017"] = 32] = "ContainsES2017";
                    TransformFlags[TransformFlags["ContainsES2016"] = 64] = "ContainsES2016";
                    TransformFlags[TransformFlags["ContainsES2015"] = 128] = "ContainsES2015";
                    TransformFlags[TransformFlags["ContainsGenerator"] = 256] = "ContainsGenerator";
                    TransformFlags[TransformFlags["ContainsDestructuringAssignment"] = 512] = "ContainsDestructuringAssignment";
                    // Markers
                    // - Flags used to indicate that a subtree contains a specific transformation.
                    TransformFlags[TransformFlags["ContainsTypeScriptClassSyntax"] = 1024] = "ContainsTypeScriptClassSyntax";
                    TransformFlags[TransformFlags["ContainsLexicalThis"] = 2048] = "ContainsLexicalThis";
                    TransformFlags[TransformFlags["ContainsRestOrSpread"] = 4096] = "ContainsRestOrSpread";
                    TransformFlags[TransformFlags["ContainsObjectRestOrSpread"] = 8192] = "ContainsObjectRestOrSpread";
                    TransformFlags[TransformFlags["ContainsComputedPropertyName"] = 16384] = "ContainsComputedPropertyName";
                    TransformFlags[TransformFlags["ContainsBlockScopedBinding"] = 32768] = "ContainsBlockScopedBinding";
                    TransformFlags[TransformFlags["ContainsBindingPattern"] = 65536] = "ContainsBindingPattern";
                    TransformFlags[TransformFlags["ContainsYield"] = 131072] = "ContainsYield";
                    TransformFlags[TransformFlags["ContainsHoistedDeclarationOrCompletion"] = 262144] = "ContainsHoistedDeclarationOrCompletion";
                    TransformFlags[TransformFlags["ContainsDynamicImport"] = 524288] = "ContainsDynamicImport";
                    // Please leave this as 1 << 29.
                    // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
                    // It is a good reminder of how much room we have left
                    TransformFlags[TransformFlags["HasComputedFlags"] = 536870912] = "HasComputedFlags";
                    // Assertions
                    // - Bitmasks that are used to assert facts about the syntax of a node and its subtree.
                    TransformFlags[TransformFlags["AssertTypeScript"] = 1] = "AssertTypeScript";
                    TransformFlags[TransformFlags["AssertJsx"] = 2] = "AssertJsx";
                    TransformFlags[TransformFlags["AssertESNext"] = 4] = "AssertESNext";
                    TransformFlags[TransformFlags["AssertES2019"] = 8] = "AssertES2019";
                    TransformFlags[TransformFlags["AssertES2018"] = 16] = "AssertES2018";
                    TransformFlags[TransformFlags["AssertES2017"] = 32] = "AssertES2017";
                    TransformFlags[TransformFlags["AssertES2016"] = 64] = "AssertES2016";
                    TransformFlags[TransformFlags["AssertES2015"] = 128] = "AssertES2015";
                    TransformFlags[TransformFlags["AssertGenerator"] = 256] = "AssertGenerator";
                    TransformFlags[TransformFlags["AssertDestructuringAssignment"] = 512] = "AssertDestructuringAssignment";
                    // Scope Exclusions
                    // - Bitmasks that exclude flags from propagating out of a specific context
                    //   into the subtree flags of their container.
                    TransformFlags[TransformFlags["OuterExpressionExcludes"] = 536870912] = "OuterExpressionExcludes";
                    TransformFlags[TransformFlags["PropertyAccessExcludes"] = 536870912] = "PropertyAccessExcludes";
                    TransformFlags[TransformFlags["NodeExcludes"] = 536870912] = "NodeExcludes";
                    TransformFlags[TransformFlags["ArrowFunctionExcludes"] = 537371648] = "ArrowFunctionExcludes";
                    TransformFlags[TransformFlags["FunctionExcludes"] = 537373696] = "FunctionExcludes";
                    TransformFlags[TransformFlags["ConstructorExcludes"] = 537372672] = "ConstructorExcludes";
                    TransformFlags[TransformFlags["MethodOrAccessorExcludes"] = 537372672] = "MethodOrAccessorExcludes";
                    TransformFlags[TransformFlags["PropertyExcludes"] = 536872960] = "PropertyExcludes";
                    TransformFlags[TransformFlags["ClassExcludes"] = 536888320] = "ClassExcludes";
                    TransformFlags[TransformFlags["ModuleExcludes"] = 537168896] = "ModuleExcludes";
                    TransformFlags[TransformFlags["TypeExcludes"] = -2] = "TypeExcludes";
                    TransformFlags[TransformFlags["ObjectLiteralExcludes"] = 536896512] = "ObjectLiteralExcludes";
                    TransformFlags[TransformFlags["ArrayLiteralOrCallOrNewExcludes"] = 536875008] = "ArrayLiteralOrCallOrNewExcludes";
                    TransformFlags[TransformFlags["VariableDeclarationListExcludes"] = 536944640] = "VariableDeclarationListExcludes";
                    TransformFlags[TransformFlags["ParameterExcludes"] = 536870912] = "ParameterExcludes";
                    TransformFlags[TransformFlags["CatchClauseExcludes"] = 536879104] = "CatchClauseExcludes";
                    TransformFlags[TransformFlags["BindingPatternExcludes"] = 536875008] = "BindingPatternExcludes";
                    // Propagating flags
                    // - Bitmasks for flags that should propagate from a child
                    TransformFlags[TransformFlags["PropertyNamePropagatingFlags"] = 2048] = "PropertyNamePropagatingFlags";
                    // Masks
                    // - Additional bitmasks
                })(TransformFlags = ts.TransformFlags || (ts.TransformFlags = {}));
                var EmitFlags;
                (function (EmitFlags) {
                    EmitFlags[EmitFlags["None"] = 0] = "None";
                    EmitFlags[EmitFlags["SingleLine"] = 1] = "SingleLine";
                    EmitFlags[EmitFlags["AdviseOnEmitNode"] = 2] = "AdviseOnEmitNode";
                    EmitFlags[EmitFlags["NoSubstitution"] = 4] = "NoSubstitution";
                    EmitFlags[EmitFlags["CapturesThis"] = 8] = "CapturesThis";
                    EmitFlags[EmitFlags["NoLeadingSourceMap"] = 16] = "NoLeadingSourceMap";
                    EmitFlags[EmitFlags["NoTrailingSourceMap"] = 32] = "NoTrailingSourceMap";
                    EmitFlags[EmitFlags["NoSourceMap"] = 48] = "NoSourceMap";
                    EmitFlags[EmitFlags["NoNestedSourceMaps"] = 64] = "NoNestedSourceMaps";
                    EmitFlags[EmitFlags["NoTokenLeadingSourceMaps"] = 128] = "NoTokenLeadingSourceMaps";
                    EmitFlags[EmitFlags["NoTokenTrailingSourceMaps"] = 256] = "NoTokenTrailingSourceMaps";
                    EmitFlags[EmitFlags["NoTokenSourceMaps"] = 384] = "NoTokenSourceMaps";
                    EmitFlags[EmitFlags["NoLeadingComments"] = 512] = "NoLeadingComments";
                    EmitFlags[EmitFlags["NoTrailingComments"] = 1024] = "NoTrailingComments";
                    EmitFlags[EmitFlags["NoComments"] = 1536] = "NoComments";
                    EmitFlags[EmitFlags["NoNestedComments"] = 2048] = "NoNestedComments";
                    EmitFlags[EmitFlags["HelperName"] = 4096] = "HelperName";
                    EmitFlags[EmitFlags["ExportName"] = 8192] = "ExportName";
                    EmitFlags[EmitFlags["LocalName"] = 16384] = "LocalName";
                    EmitFlags[EmitFlags["InternalName"] = 32768] = "InternalName";
                    EmitFlags[EmitFlags["Indented"] = 65536] = "Indented";
                    EmitFlags[EmitFlags["NoIndentation"] = 131072] = "NoIndentation";
                    EmitFlags[EmitFlags["AsyncFunctionBody"] = 262144] = "AsyncFunctionBody";
                    EmitFlags[EmitFlags["ReuseTempVariableScope"] = 524288] = "ReuseTempVariableScope";
                    EmitFlags[EmitFlags["CustomPrologue"] = 1048576] = "CustomPrologue";
                    EmitFlags[EmitFlags["NoHoisting"] = 2097152] = "NoHoisting";
                    EmitFlags[EmitFlags["HasEndOfDeclarationMarker"] = 4194304] = "HasEndOfDeclarationMarker";
                    EmitFlags[EmitFlags["Iterator"] = 8388608] = "Iterator";
                    EmitFlags[EmitFlags["NoAsciiEscaping"] = 16777216] = "NoAsciiEscaping";
                    /*@internal*/ EmitFlags[EmitFlags["TypeScriptClassWrapper"] = 33554432] = "TypeScriptClassWrapper";
                    /*@internal*/ EmitFlags[EmitFlags["NeverApplyImportHelper"] = 67108864] = "NeverApplyImportHelper";
                })(EmitFlags = ts.EmitFlags || (ts.EmitFlags = {}));
                /**
                 * Used by the checker, this enum keeps track of external emit helpers that should be type
                 * checked.
                 */
                /* @internal */
                var ExternalEmitHelpers;
                (function (ExternalEmitHelpers) {
                    ExternalEmitHelpers[ExternalEmitHelpers["Extends"] = 1] = "Extends";
                    ExternalEmitHelpers[ExternalEmitHelpers["Assign"] = 2] = "Assign";
                    ExternalEmitHelpers[ExternalEmitHelpers["Rest"] = 4] = "Rest";
                    ExternalEmitHelpers[ExternalEmitHelpers["Decorate"] = 8] = "Decorate";
                    ExternalEmitHelpers[ExternalEmitHelpers["Metadata"] = 16] = "Metadata";
                    ExternalEmitHelpers[ExternalEmitHelpers["Param"] = 32] = "Param";
                    ExternalEmitHelpers[ExternalEmitHelpers["Awaiter"] = 64] = "Awaiter";
                    ExternalEmitHelpers[ExternalEmitHelpers["Generator"] = 128] = "Generator";
                    ExternalEmitHelpers[ExternalEmitHelpers["Values"] = 256] = "Values";
                    ExternalEmitHelpers[ExternalEmitHelpers["Read"] = 512] = "Read";
                    ExternalEmitHelpers[ExternalEmitHelpers["Spread"] = 1024] = "Spread";
                    ExternalEmitHelpers[ExternalEmitHelpers["Await"] = 2048] = "Await";
                    ExternalEmitHelpers[ExternalEmitHelpers["AsyncGenerator"] = 4096] = "AsyncGenerator";
                    ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegator"] = 8192] = "AsyncDelegator";
                    ExternalEmitHelpers[ExternalEmitHelpers["AsyncValues"] = 16384] = "AsyncValues";
                    ExternalEmitHelpers[ExternalEmitHelpers["ExportStar"] = 32768] = "ExportStar";
                    ExternalEmitHelpers[ExternalEmitHelpers["MakeTemplateObject"] = 65536] = "MakeTemplateObject";
                    ExternalEmitHelpers[ExternalEmitHelpers["FirstEmitHelper"] = 1] = "FirstEmitHelper";
                    ExternalEmitHelpers[ExternalEmitHelpers["LastEmitHelper"] = 65536] = "LastEmitHelper";
                    // Helpers included by ES2015 for..of
                    ExternalEmitHelpers[ExternalEmitHelpers["ForOfIncludes"] = 256] = "ForOfIncludes";
                    // Helpers included by ES2017 for..await..of
                    ExternalEmitHelpers[ExternalEmitHelpers["ForAwaitOfIncludes"] = 16384] = "ForAwaitOfIncludes";
                    // Helpers included by ES2017 async generators
                    ExternalEmitHelpers[ExternalEmitHelpers["AsyncGeneratorIncludes"] = 6144] = "AsyncGeneratorIncludes";
                    // Helpers included by yield* in ES2017 async generators
                    ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegatorIncludes"] = 26624] = "AsyncDelegatorIncludes";
                    // Helpers included by ES2015 spread
                    ExternalEmitHelpers[ExternalEmitHelpers["SpreadIncludes"] = 1536] = "SpreadIncludes";
                })(ExternalEmitHelpers = ts.ExternalEmitHelpers || (ts.ExternalEmitHelpers = {}));
                var EmitHint;
                (function (EmitHint) {
                    EmitHint[EmitHint["SourceFile"] = 0] = "SourceFile";
                    EmitHint[EmitHint["Expression"] = 1] = "Expression";
                    EmitHint[EmitHint["IdentifierName"] = 2] = "IdentifierName";
                    EmitHint[EmitHint["MappedTypeParameter"] = 3] = "MappedTypeParameter";
                    EmitHint[EmitHint["Unspecified"] = 4] = "Unspecified";
                    EmitHint[EmitHint["EmbeddedStatement"] = 5] = "EmbeddedStatement";
                })(EmitHint = ts.EmitHint || (ts.EmitHint = {}));
                /*@internal*/
                var BundleFileSectionKind;
                (function (BundleFileSectionKind) {
                    BundleFileSectionKind["Prologue"] = "prologue";
                    BundleFileSectionKind["EmitHelpers"] = "emitHelpers";
                    BundleFileSectionKind["NoDefaultLib"] = "no-default-lib";
                    BundleFileSectionKind["Reference"] = "reference";
                    BundleFileSectionKind["Type"] = "type";
                    BundleFileSectionKind["Lib"] = "lib";
                    BundleFileSectionKind["Prepend"] = "prepend";
                    BundleFileSectionKind["Text"] = "text";
                    BundleFileSectionKind["Internal"] = "internal";
                    // comments?
                })(BundleFileSectionKind = ts.BundleFileSectionKind || (ts.BundleFileSectionKind = {}));
                var ListFormat;
                (function (ListFormat) {
                    ListFormat[ListFormat["None"] = 0] = "None";
                    // Line separators
                    ListFormat[ListFormat["SingleLine"] = 0] = "SingleLine";
                    ListFormat[ListFormat["MultiLine"] = 1] = "MultiLine";
                    ListFormat[ListFormat["PreserveLines"] = 2] = "PreserveLines";
                    ListFormat[ListFormat["LinesMask"] = 3] = "LinesMask";
                    // Delimiters
                    ListFormat[ListFormat["NotDelimited"] = 0] = "NotDelimited";
                    ListFormat[ListFormat["BarDelimited"] = 4] = "BarDelimited";
                    ListFormat[ListFormat["AmpersandDelimited"] = 8] = "AmpersandDelimited";
                    ListFormat[ListFormat["CommaDelimited"] = 16] = "CommaDelimited";
                    ListFormat[ListFormat["AsteriskDelimited"] = 32] = "AsteriskDelimited";
                    ListFormat[ListFormat["DelimitersMask"] = 60] = "DelimitersMask";
                    ListFormat[ListFormat["AllowTrailingComma"] = 64] = "AllowTrailingComma";
                    // Whitespace
                    ListFormat[ListFormat["Indented"] = 128] = "Indented";
                    ListFormat[ListFormat["SpaceBetweenBraces"] = 256] = "SpaceBetweenBraces";
                    ListFormat[ListFormat["SpaceBetweenSiblings"] = 512] = "SpaceBetweenSiblings";
                    // Brackets/Braces
                    ListFormat[ListFormat["Braces"] = 1024] = "Braces";
                    ListFormat[ListFormat["Parenthesis"] = 2048] = "Parenthesis";
                    ListFormat[ListFormat["AngleBrackets"] = 4096] = "AngleBrackets";
                    ListFormat[ListFormat["SquareBrackets"] = 8192] = "SquareBrackets";
                    ListFormat[ListFormat["BracketsMask"] = 15360] = "BracketsMask";
                    ListFormat[ListFormat["OptionalIfUndefined"] = 16384] = "OptionalIfUndefined";
                    ListFormat[ListFormat["OptionalIfEmpty"] = 32768] = "OptionalIfEmpty";
                    ListFormat[ListFormat["Optional"] = 49152] = "Optional";
                    // Other
                    ListFormat[ListFormat["PreferNewLine"] = 65536] = "PreferNewLine";
                    ListFormat[ListFormat["NoTrailingNewLine"] = 131072] = "NoTrailingNewLine";
                    ListFormat[ListFormat["NoInterveningComments"] = 262144] = "NoInterveningComments";
                    ListFormat[ListFormat["NoSpaceIfEmpty"] = 524288] = "NoSpaceIfEmpty";
                    ListFormat[ListFormat["SingleElement"] = 1048576] = "SingleElement";
                    // Precomputed Formats
                    ListFormat[ListFormat["Modifiers"] = 262656] = "Modifiers";
                    ListFormat[ListFormat["HeritageClauses"] = 512] = "HeritageClauses";
                    ListFormat[ListFormat["SingleLineTypeLiteralMembers"] = 768] = "SingleLineTypeLiteralMembers";
                    ListFormat[ListFormat["MultiLineTypeLiteralMembers"] = 32897] = "MultiLineTypeLiteralMembers";
                    ListFormat[ListFormat["TupleTypeElements"] = 528] = "TupleTypeElements";
                    ListFormat[ListFormat["UnionTypeConstituents"] = 516] = "UnionTypeConstituents";
                    ListFormat[ListFormat["IntersectionTypeConstituents"] = 520] = "IntersectionTypeConstituents";
                    ListFormat[ListFormat["ObjectBindingPatternElements"] = 525136] = "ObjectBindingPatternElements";
                    ListFormat[ListFormat["ArrayBindingPatternElements"] = 524880] = "ArrayBindingPatternElements";
                    ListFormat[ListFormat["ObjectLiteralExpressionProperties"] = 526226] = "ObjectLiteralExpressionProperties";
                    ListFormat[ListFormat["ArrayLiteralExpressionElements"] = 8914] = "ArrayLiteralExpressionElements";
                    ListFormat[ListFormat["CommaListElements"] = 528] = "CommaListElements";
                    ListFormat[ListFormat["CallExpressionArguments"] = 2576] = "CallExpressionArguments";
                    ListFormat[ListFormat["NewExpressionArguments"] = 18960] = "NewExpressionArguments";
                    ListFormat[ListFormat["TemplateExpressionSpans"] = 262144] = "TemplateExpressionSpans";
                    ListFormat[ListFormat["SingleLineBlockStatements"] = 768] = "SingleLineBlockStatements";
                    ListFormat[ListFormat["MultiLineBlockStatements"] = 129] = "MultiLineBlockStatements";
                    ListFormat[ListFormat["VariableDeclarationList"] = 528] = "VariableDeclarationList";
                    ListFormat[ListFormat["SingleLineFunctionBodyStatements"] = 768] = "SingleLineFunctionBodyStatements";
                    ListFormat[ListFormat["MultiLineFunctionBodyStatements"] = 1] = "MultiLineFunctionBodyStatements";
                    ListFormat[ListFormat["ClassHeritageClauses"] = 0] = "ClassHeritageClauses";
                    ListFormat[ListFormat["ClassMembers"] = 129] = "ClassMembers";
                    ListFormat[ListFormat["InterfaceMembers"] = 129] = "InterfaceMembers";
                    ListFormat[ListFormat["EnumMembers"] = 145] = "EnumMembers";
                    ListFormat[ListFormat["CaseBlockClauses"] = 129] = "CaseBlockClauses";
                    ListFormat[ListFormat["NamedImportsOrExportsElements"] = 525136] = "NamedImportsOrExportsElements";
                    ListFormat[ListFormat["JsxElementOrFragmentChildren"] = 262144] = "JsxElementOrFragmentChildren";
                    ListFormat[ListFormat["JsxElementAttributes"] = 262656] = "JsxElementAttributes";
                    ListFormat[ListFormat["CaseOrDefaultClauseStatements"] = 163969] = "CaseOrDefaultClauseStatements";
                    ListFormat[ListFormat["HeritageClauseTypes"] = 528] = "HeritageClauseTypes";
                    ListFormat[ListFormat["SourceFileStatements"] = 131073] = "SourceFileStatements";
                    ListFormat[ListFormat["Decorators"] = 49153] = "Decorators";
                    ListFormat[ListFormat["TypeArguments"] = 53776] = "TypeArguments";
                    ListFormat[ListFormat["TypeParameters"] = 53776] = "TypeParameters";
                    ListFormat[ListFormat["Parameters"] = 2576] = "Parameters";
                    ListFormat[ListFormat["IndexSignatureParameters"] = 8848] = "IndexSignatureParameters";
                    ListFormat[ListFormat["JSDocComment"] = 33] = "JSDocComment";
                })(ListFormat = ts.ListFormat || (ts.ListFormat = {}));
                /* @internal */
                var PragmaKindFlags;
                (function (PragmaKindFlags) {
                    PragmaKindFlags[PragmaKindFlags["None"] = 0] = "None";
                    /**
                     * Triple slash comment of the form
                     * /// <pragma-name argname="value" />
                     */
                    PragmaKindFlags[PragmaKindFlags["TripleSlashXML"] = 1] = "TripleSlashXML";
                    /**
                     * Single line comment of the form
                     * // @pragma-name argval1 argval2
                     * or
                     * /// @pragma-name argval1 argval2
                     */
                    PragmaKindFlags[PragmaKindFlags["SingleLine"] = 2] = "SingleLine";
                    /**
                     * Multiline non-jsdoc pragma of the form
                     * /* @pragma-name argval1 argval2 * /
                     */
                    PragmaKindFlags[PragmaKindFlags["MultiLine"] = 4] = "MultiLine";
                    PragmaKindFlags[PragmaKindFlags["All"] = 7] = "All";
                    PragmaKindFlags[PragmaKindFlags["Default"] = 7] = "Default";
                })(PragmaKindFlags = ts.PragmaKindFlags || (ts.PragmaKindFlags = {}));
                /**
                 * This function only exists to cause exact types to be inferred for all the literals within `commentPragmas`
                 */
                /* @internal */
                function _contextuallyTypePragmas(args) {
                    return args;
                }
                // While not strictly a type, this is here because `PragmaMap` needs to be here to be used with `SourceFile`, and we don't
                //  fancy effectively defining it twice, once in value-space and once in type-space
                /* @internal */
                ts.commentPragmas = _contextuallyTypePragmas({
                    "reference": {
                        args: [
                            { name: "types", optional: true, captureSpan: true },
                            { name: "lib", optional: true, captureSpan: true },
                            { name: "path", optional: true, captureSpan: true },
                            { name: "no-default-lib", optional: true }
                        ],
                        kind: 1 /* TripleSlashXML */
                    },
                    "amd-dependency": {
                        args: [{ name: "path" }, { name: "name", optional: true }],
                        kind: 1 /* TripleSlashXML */
                    },
                    "amd-module": {
                        args: [{ name: "name" }],
                        kind: 1 /* TripleSlashXML */
                    },
                    "ts-check": {
                        kind: 2 /* SingleLine */
                    },
                    "ts-nocheck": {
                        kind: 2 /* SingleLine */
                    },
                    "jsx": {
                        args: [{ name: "factory" }],
                        kind: 4 /* MultiLine */
                    },
                });
            })(ts || (ts = {}));
            var ts;
            (function (ts) {
                /**
                 * djb2 hashing algorithm
                 * http://www.cse.yorku.ca/~oz/hash.html
                 */
                /* @internal */
                function generateDjb2Hash(data) {
                    var acc = 5381;
                    for (var i = 0; i < data.length; i++) {
                        acc = ((acc << 5) + acc) + data.charCodeAt(i);
                    }
                    return acc.toString();
                }
                ts.generateDjb2Hash = generateDjb2Hash;
                /**
                 * Set a high stack trace limit to provide more information in case of an error.
                 * Called for command-line and server use cases.
                 * Not called if TypeScript is used as a library.
                 */
                /* @internal */
                function setStackTraceLimit() {
                    if (Error.stackTraceLimit < 100) { // Also tests that we won't set the property if it doesn't exist.
                        Error.stackTraceLimit = 100;
                    }
                }
                ts.setStackTraceLimit = setStackTraceLimit;
                var FileWatcherEventKind;
                (function (FileWatcherEventKind) {
                    FileWatcherEventKind[FileWatcherEventKind["Created"] = 0] = "Created";
                    FileWatcherEventKind[FileWatcherEventKind["Changed"] = 1] = "Changed";
                    FileWatcherEventKind[FileWatcherEventKind["Deleted"] = 2] = "Deleted";
                })(FileWatcherEventKind = ts.FileWatcherEventKind || (ts.FileWatcherEventKind = {}));
                /* @internal */
                var PollingInterval;
                (function (PollingInterval) {
                    PollingInterval[PollingInterval["High"] = 2000] = "High";
                    PollingInterval[PollingInterval["Medium"] = 500] = "Medium";
                    PollingInterval[PollingInterval["Low"] = 250] = "Low";
                })(PollingInterval = ts.PollingInterval || (ts.PollingInterval = {}));
                /* @internal */
                ts.missingFileModifiedTime = new Date(0); // Any subsequent modification will occur after this time
                function createPollingIntervalBasedLevels(levels) {
                    var _a;
                    return _a = {},
                        _a[PollingInterval.Low] = levels.Low,
                        _a[PollingInterval.Medium] = levels.Medium,
                        _a[PollingInterval.High] = levels.High,
                        _a;
                }
                var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 };
                var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels);
                /* @internal */
                ts.unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
                /* @internal */
                function setCustomPollingValues(system) {
                    if (!system.getEnvironmentVariable) {
                        return;
                    }
                    var pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval);
                    pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;
                    ts.unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || ts.unchangedPollThresholds;
                    function getLevel(envVar, level) {
                        return system.getEnvironmentVariable(envVar + "_" + level.toUpperCase());
                    }
                    function getCustomLevels(baseVariable) {
                        var customLevels;
                        setCustomLevel("Low");
                        setCustomLevel("Medium");
                        setCustomLevel("High");
                        return customLevels;
                        function setCustomLevel(level) {
                            var customLevel = getLevel(baseVariable, level);
                            if (customLevel) {
                                (customLevels || (customLevels = {}))[level] = Number(customLevel);
                            }
                        }
                    }
                    function setCustomLevels(baseVariable, levels) {
                        var customLevels = getCustomLevels(baseVariable);
                        if (customLevels) {
                            setLevel("Low");
                            setLevel("Medium");
                            setLevel("High");
                            return true;
                        }
                        return false;
                        function setLevel(level) {
                            levels[level] = customLevels[level] || levels[level];
                        }
                    }
                    function getCustomPollingBasedLevels(baseVariable, defaultLevels) {
                        var customLevels = getCustomLevels(baseVariable);
                        return (pollingIntervalChanged || customLevels) &&
                            createPollingIntervalBasedLevels(customLevels ? __assign({}, defaultLevels, customLevels) : defaultLevels);
                    }
                }
                ts.setCustomPollingValues = setCustomPollingValues;
                /* @internal */
                function createDynamicPriorityPollingWatchFile(host) {
                    var watchedFiles = [];
                    var changedFilesInLastPoll = [];
                    var lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low);
                    var mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium);
                    var highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High);
                    return watchFile;
                    function watchFile(fileName, callback, defaultPollingInterval) {
                        var file = {
                            fileName: fileName,
                            callback: callback,
                            unchangedPolls: 0,
                            mtime: getModifiedTime(fileName)
                        };
                        watchedFiles.push(file);
                        addToPollingIntervalQueue(file, defaultPollingInterval);
                        return {
                            close: function () {
                                file.isClosed = true;
                                // Remove from watchedFiles
                                ts.unorderedRemoveItem(watchedFiles, file);
                                // Do not update polling interval queue since that will happen as part of polling
                            }
                        };
                    }
                    function createPollingIntervalQueue(pollingInterval) {
                        var queue = [];
                        queue.pollingInterval = pollingInterval;
                        queue.pollIndex = 0;
                        queue.pollScheduled = false;
                        return queue;
                    }
                    function pollPollingIntervalQueue(queue) {
                        queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]);
                        // Set the next polling index and timeout
                        if (queue.length) {
                            scheduleNextPoll(queue.pollingInterval);
                        }
                        else {
                            ts.Debug.assert(queue.pollIndex === 0);
                            queue.pollScheduled = false;
                        }
                    }
                    function pollLowPollingIntervalQueue(queue) {
                        // Always poll complete list of changedFilesInLastPoll
                        pollQueue(changedFilesInLastPoll, PollingInterval.Low, /*pollIndex*/ 0, changedFilesInLastPoll.length);
                        // Finally do the actual polling of the queue
                        pollPollingIntervalQueue(queue);
                        // Schedule poll if there are files in changedFilesInLastPoll but no files in the actual queue
                        // as pollPollingIntervalQueue wont schedule for next poll
                        if (!queue.pollScheduled && changedFilesInLastPoll.length) {
                            scheduleNextPoll(PollingInterval.Low);
                        }
                    }
                    function pollQueue(queue, pollingInterval, pollIndex, chunkSize) {
                        // Max visit would be all elements of the queue
                        var needsVisit = queue.length;
                        var definedValueCopyToIndex = pollIndex;
                        for (var polled = 0; polled < chunkSize && needsVisit > 0; nextPollIndex(), needsVisit--) {
                            var watchedFile = queue[pollIndex];
                            if (!watchedFile) {
                                continue;
                            }
                            else if (watchedFile.isClosed) {
                                queue[pollIndex] = undefined;
                                continue;
                            }
                            polled++;
                            var fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(watchedFile.fileName));
                            if (watchedFile.isClosed) {
                                // Closed watcher as part of callback
                                queue[pollIndex] = undefined;
                            }
                            else if (fileChanged) {
                                watchedFile.unchangedPolls = 0;
                                // Changed files go to changedFilesInLastPoll queue
                                if (queue !== changedFilesInLastPoll) {
                                    queue[pollIndex] = undefined;
                                    addChangedFileToLowPollingIntervalQueue(watchedFile);
                                }
                            }
                            else if (watchedFile.unchangedPolls !== ts.unchangedPollThresholds[pollingInterval]) {
                                watchedFile.unchangedPolls++;
                            }
                            else if (queue === changedFilesInLastPoll) {
                                // Restart unchangedPollCount for unchanged file and move to low polling interval queue
                                watchedFile.unchangedPolls = 1;
                                queue[pollIndex] = undefined;
                                addToPollingIntervalQueue(watchedFile, PollingInterval.Low);
                            }
                            else if (pollingInterval !== PollingInterval.High) {
                                watchedFile.unchangedPolls++;
                                queue[pollIndex] = undefined;
                                addToPollingIntervalQueue(watchedFile, pollingInterval === PollingInterval.Low ? PollingInterval.Medium : PollingInterval.High);
                            }
                            if (queue[pollIndex]) {
                                // Copy this file to the non hole location
                                if (definedValueCopyToIndex < pollIndex) {
                                    queue[definedValueCopyToIndex] = watchedFile;
                                    queue[pollIndex] = undefined;
                                }
                                definedValueCopyToIndex++;
                            }
                        }
                        // Return next poll index
                        return pollIndex;
                        function nextPollIndex() {
                            pollIndex++;
                            if (pollIndex === queue.length) {
                                if (definedValueCopyToIndex < pollIndex) {
                                    // There are holes from nextDefinedValueIndex to end of queue, change queue size
                                    queue.length = definedValueCopyToIndex;
                                }
                                pollIndex = 0;
                                definedValueCopyToIndex = 0;
                            }
                        }
                    }
                    function pollingIntervalQueue(pollingInterval) {
                        switch (pollingInterval) {
                            case PollingInterval.Low:
                                return lowPollingIntervalQueue;
                            case PollingInterval.Medium:
                                return mediumPollingIntervalQueue;
                            case PollingInterval.High:
                                return highPollingIntervalQueue;
                        }
                    }
                    function addToPollingIntervalQueue(file, pollingInterval) {
                        pollingIntervalQueue(pollingInterval).push(file);
                        scheduleNextPollIfNotAlreadyScheduled(pollingInterval);
                    }
                    function addChangedFileToLowPollingIntervalQueue(file) {
                        changedFilesInLastPoll.push(file);
                        scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low);
                    }
                    function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) {
                        if (!pollingIntervalQueue(pollingInterval).pollScheduled) {
                            scheduleNextPoll(pollingInterval);
                        }
                    }
                    function scheduleNextPoll(pollingInterval) {
                        pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval));
                    }
                    function getModifiedTime(fileName) {
                        return host.getModifiedTime(fileName) || ts.missingFileModifiedTime;
                    }
                }
                ts.createDynamicPriorityPollingWatchFile = createDynamicPriorityPollingWatchFile;
                /**
                 * Returns true if file status changed
                 */
                /*@internal*/
                function onWatchedFileStat(watchedFile, modifiedTime) {
                    var oldTime = watchedFile.mtime.getTime();
                    var newTime = modifiedTime.getTime();
                    if (oldTime !== newTime) {
                        watchedFile.mtime = modifiedTime;
                        watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime));
                        return true;
                    }
                    return false;
                }
                ts.onWatchedFileStat = onWatchedFileStat;
                /*@internal*/
                function getFileWatcherEventKind(oldTime, newTime) {
                    return oldTime === 0
                        ? FileWatcherEventKind.Created
                        : newTime === 0
                            ? FileWatcherEventKind.Deleted
                            : FileWatcherEventKind.Changed;
                }
                ts.getFileWatcherEventKind = getFileWatcherEventKind;
                /*@internal*/
                ts.ignoredPaths = ["/node_modules/.", "/.git"];
                /**
                 * Watch the directory recursively using host provided method to watch child directories
                 * that means if this is recursive watcher, watch the children directories as well
                 * (eg on OS that dont support recursive watch using fs.watch use fs.watchFile)
                 */
                /*@internal*/
                function createRecursiveDirectoryWatcher(host) {
                    var cache = ts.createMap();
                    var callbackCache = ts.createMultiMap();
                    var filePathComparer = ts.getStringComparer(!host.useCaseSensitiveFileNames);
                    var toCanonicalFilePath = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
                    return createDirectoryWatcher;
                    /**
                     * Create the directory watcher for the dirPath.
                     */
                    function createDirectoryWatcher(dirName, callback) {
                        var dirPath = toCanonicalFilePath(dirName);
                        var directoryWatcher = cache.get(dirPath);
                        if (directoryWatcher) {
                            directoryWatcher.refCount++;
                        }
                        else {
                            directoryWatcher = {
                                watcher: host.watchDirectory(dirName, function (fileName) {
                                    if (isIgnoredPath(fileName))
                                        return;
                                    // Call the actual callback
                                    callbackCache.forEach(function (callbacks, rootDirName) {
                                        if (rootDirName === dirPath || (ts.startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === ts.directorySeparator)) {
                                            callbacks.forEach(function (callback) { return callback(fileName); });
                                        }
                                    });
                                    // Iterate through existing children and update the watches if needed
                                    updateChildWatches(dirName, dirPath);
                                }),
                                refCount: 1,
                                childWatches: ts.emptyArray
                            };
                            cache.set(dirPath, directoryWatcher);
                            updateChildWatches(dirName, dirPath);
                        }
                        if (callback) {
                            callbackCache.add(dirPath, callback);
                        }
                        return {
                            dirName: dirName,
                            close: function () {
                                var directoryWatcher = ts.Debug.assertDefined(cache.get(dirPath));
                                if (callback)
                                    callbackCache.remove(dirPath, callback);
                                directoryWatcher.refCount--;
                                if (directoryWatcher.refCount)
                                    return;
                                cache.delete(dirPath);
                                ts.closeFileWatcherOf(directoryWatcher);
                                directoryWatcher.childWatches.forEach(ts.closeFileWatcher);
                            }
                        };
                    }
                    function updateChildWatches(dirName, dirPath) {
                        // Iterate through existing children and update the watches if needed
                        var parentWatcher = cache.get(dirPath);
                        if (parentWatcher) {
                            parentWatcher.childWatches = watchChildDirectories(dirName, parentWatcher.childWatches);
                        }
                    }
                    /**
                     * Watch the directories in the parentDir
                     */
                    function watchChildDirectories(parentDir, existingChildWatches) {
                        var newChildWatches;
                        ts.enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts.mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) {
                            var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
                            // Filter our the symbolic link directories since those arent included in recursive watch
                            // which is same behaviour when recursive: true is passed to fs.watch
                            return !isIgnoredPath(childFullName) && filePathComparer(childFullName, ts.normalizePath(host.realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : undefined;
                        }) : ts.emptyArray, existingChildWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher);
                        return newChildWatches || ts.emptyArray;
                        /**
                         * Create new childDirectoryWatcher and add it to the new ChildDirectoryWatcher list
                         */
                        function createAndAddChildDirectoryWatcher(childName) {
                            var result = createDirectoryWatcher(childName);
                            addChildDirectoryWatcher(result);
                        }
                        /**
                         * Add child directory watcher to the new ChildDirectoryWatcher list
                         */
                        function addChildDirectoryWatcher(childWatcher) {
                            (newChildWatches || (newChildWatches = [])).push(childWatcher);
                        }
                    }
                    function isIgnoredPath(path) {
                        return ts.some(ts.ignoredPaths, function (searchPath) { return isInPath(path, searchPath); });
                    }
                    function isInPath(path, searchPath) {
                        if (ts.stringContains(path, searchPath))
                            return true;
                        if (host.useCaseSensitiveFileNames)
                            return false;
                        return ts.stringContains(toCanonicalFilePath(path), searchPath);
                    }
                }
                ts.createRecursiveDirectoryWatcher = createRecursiveDirectoryWatcher;
                function getNodeMajorVersion() {
                    if (typeof process === "undefined") {
                        return undefined;
                    }
                    var version = process.version;
                    if (!version) {
                        return undefined;
                    }
                    var dot = version.indexOf(".");
                    if (dot === -1) {
                        return undefined;
                    }
                    return parseInt(version.substring(1, dot));
                }
                ts.getNodeMajorVersion = getNodeMajorVersion;
                // TODO: GH#18217 this is used as if it's certainly defined in many places.
                ts.sys = (function () {
                    // NodeJS detects "\uFEFF" at the start of the string and *replaces* it with the actual
                    // byte order mark from the specified encoding. Using any other byte order mark does
                    // not actually work.
                    var byteOrderMarkIndicator = "\uFEFF";
                    function getNodeSystem() {
                        var _fs = require$$3;
                        var _path = require$$3;
                        var _os = require$$3;
                        // crypto can be absent on reduced node installations
                        var _crypto;
                        try {
                            _crypto = require$$3;
                        }
                        catch (_a) {
                            _crypto = undefined;
                        }
                        var Buffer = require$$3.Buffer;
                        var nodeVersion = getNodeMajorVersion();
                        var isNode4OrLater = nodeVersion >= 4;
                        var platform = _os.platform();
                        var useCaseSensitiveFileNames = isFileSystemCaseSensitive();
                        var FileSystemEntryKind;
                        (function (FileSystemEntryKind) {
                            FileSystemEntryKind[FileSystemEntryKind["File"] = 0] = "File";
                            FileSystemEntryKind[FileSystemEntryKind["Directory"] = 1] = "Directory";
                        })(FileSystemEntryKind || (FileSystemEntryKind = {}));
                        var useNonPollingWatchers = process.env.TSC_NONPOLLING_WATCHER;
                        var tscWatchFile = process.env.TSC_WATCHFILE;
                        var tscWatchDirectory = process.env.TSC_WATCHDIRECTORY;
                        var dynamicPollingWatchFile;
                        var nodeSystem = {
                            args: process.argv.slice(2),
                            newLine: _os.EOL,
                            useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                            write: function (s) {
                                process.stdout.write(s);
                            },
                            writeOutputIsTTY: function () {
                                return process.stdout.isTTY;
                            },
                            readFile: readFile,
                            writeFile: writeFile,
                            watchFile: getWatchFile(),
                            watchDirectory: getWatchDirectory(),
                            resolvePath: function (path) { return _path.resolve(path); },
                            fileExists: fileExists,
                            directoryExists: directoryExists,
                            createDirectory: function (directoryName) {
                                if (!nodeSystem.directoryExists(directoryName)) {
                                    // Wrapped in a try-catch to prevent crashing if we are in a race
                                    // with another copy of ourselves to create the same directory
                                    try {
                                        _fs.mkdirSync(directoryName);
                                    }
                                    catch (e) {
                                        if (e.code !== "EEXIST") {
                                            // Failed for some other reason (access denied?); still throw
                                            throw e;
                                        }
                                    }
                                }
                            },
                            getExecutingFilePath: function () {
                                return __filename;
                            },
                            getCurrentDirectory: function () {
                                return process.cwd();
                            },
                            getDirectories: getDirectories,
                            getEnvironmentVariable: function (name) {
                                return process.env[name] || "";
                            },
                            readDirectory: readDirectory,
                            getModifiedTime: getModifiedTime,
                            setModifiedTime: setModifiedTime,
                            deleteFile: deleteFile,
                            createHash: _crypto ? createSHA256Hash : generateDjb2Hash,
                            createSHA256Hash: _crypto ? createSHA256Hash : undefined,
                            getMemoryUsage: function () {
                                if (commonjsGlobal.gc) {
                                    commonjsGlobal.gc();
                                }
                                return process.memoryUsage().heapUsed;
                            },
                            getFileSize: function (path) {
                                try {
                                    var stat = _fs.statSync(path);
                                    if (stat.isFile()) {
                                        return stat.size;
                                    }
                                }
                                catch ( /*ignore*/_a) { /*ignore*/ }
                                return 0;
                            },
                            exit: function (exitCode) {
                                process.exit(exitCode);
                            },
                            realpath: realpath,
                            debugMode: ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }),
                            tryEnableSourceMapsForHost: function () {
                                try {
                                    sourceMapSupport.install();
                                }
                                catch (_a) {
                                    // Could not enable source maps.
                                }
                            },
                            setTimeout: setTimeout,
                            clearTimeout: clearTimeout,
                            clearScreen: function () {
                                process.stdout.write("\x1Bc");
                            },
                            setBlocking: function () {
                            },
                            bufferFrom: bufferFrom,
                            base64decode: function (input) { return bufferFrom(input, "base64").toString("utf8"); },
                            base64encode: function (input) { return bufferFrom(input).toString("base64"); },
                        };
                        return nodeSystem;
                        function bufferFrom(input, encoding) {
                            // See https://github.com/Microsoft/TypeScript/issues/25652
                            return Buffer.from && Buffer.from !== Int8Array.from
                                ? Buffer.from(input, encoding)
                                : new Buffer(input, encoding);
                        }
                        function isFileSystemCaseSensitive() {
                            // win32\win64 are case insensitive platforms
                            if (platform === "win32" || platform === "win64") {
                                return false;
                            }
                            // If this file exists under a different case, we must be case-insensitve.
                            return !fileExists(swapCase(__filename));
                        }
                        /** Convert all lowercase chars to uppercase, and vice-versa */
                        function swapCase(s) {
                            return s.replace(/\w/g, function (ch) {
                                var up = ch.toUpperCase();
                                return ch === up ? ch.toLowerCase() : up;
                            });
                        }
                        function getWatchFile() {
                            switch (tscWatchFile) {
                                case "PriorityPollingInterval":
                                    // Use polling interval based on priority when create watch using host.watchFile
                                    return fsWatchFile;
                                case "DynamicPriorityPolling":
                                    // Use polling interval but change the interval depending on file changes and their default polling interval
                                    return createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout });
                                case "UseFsEvents":
                                    // Use notifications from FS to watch with falling back to fs.watchFile
                                    return watchFileUsingFsWatch;
                                case "UseFsEventsWithFallbackDynamicPolling":
                                    // Use notifications from FS to watch with falling back to dynamic watch file
                                    dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout });
                                    return createWatchFileUsingDynamicWatchFile(dynamicPollingWatchFile);
                                case "UseFsEventsOnParentDirectory":
                                    // Use notifications from FS to watch with falling back to fs.watchFile
                                    return createNonPollingWatchFile();
                            }
                            return useNonPollingWatchers ?
                                createNonPollingWatchFile() :
                                // Default to do not use polling interval as it is before this experiment branch
                                function (fileName, callback) { return fsWatchFile(fileName, callback); };
                        }
                        function getWatchDirectory() {
                            // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                            // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                            var fsSupportsRecursive = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
                            if (fsSupportsRecursive) {
                                return watchDirectoryUsingFsWatch;
                            }
                            var watchDirectory = tscWatchDirectory === "RecursiveDirectoryUsingFsWatchFile" ?
                                createWatchDirectoryUsing(fsWatchFile) :
                                tscWatchDirectory === "RecursiveDirectoryUsingDynamicPriorityPolling" ?
                                    createWatchDirectoryUsing(dynamicPollingWatchFile || createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout })) :
                                    watchDirectoryUsingFsWatch;
                            var watchDirectoryRecursively = createRecursiveDirectoryWatcher({
                                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                                directoryExists: directoryExists,
                                getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; },
                                watchDirectory: watchDirectory,
                                realpath: realpath
                            });
                            return function (directoryName, callback, recursive) {
                                if (recursive) {
                                    return watchDirectoryRecursively(directoryName, callback);
                                }
                                return watchDirectory(directoryName, callback);
                            };
                        }
                        function createNonPollingWatchFile() {
                            // One file can have multiple watchers
                            var fileWatcherCallbacks = ts.createMultiMap();
                            var dirWatchers = ts.createMap();
                            var toCanonicalName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
                            return nonPollingWatchFile;
                            function nonPollingWatchFile(fileName, callback) {
                                var filePath = toCanonicalName(fileName);
                                fileWatcherCallbacks.add(filePath, callback);
                                var dirPath = ts.getDirectoryPath(filePath) || ".";
                                var watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(ts.getDirectoryPath(fileName) || ".", dirPath);
                                watcher.referenceCount++;
                                return {
                                    close: function () {
                                        if (watcher.referenceCount === 1) {
                                            watcher.close();
                                            dirWatchers.delete(dirPath);
                                        }
                                        else {
                                            watcher.referenceCount--;
                                        }
                                        fileWatcherCallbacks.remove(filePath, callback);
                                    }
                                };
                            }
                            function createDirectoryWatcher(dirName, dirPath) {
                                var watcher = fsWatchDirectory(dirName, function (_eventName, relativeFileName) {
                                    // When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined"
                                    if (!ts.isString(relativeFileName)) {
                                        return;
                                    }
                                    var fileName = ts.getNormalizedAbsolutePath(relativeFileName, dirName);
                                    // Some applications save a working file via rename operations
                                    var callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));
                                    if (callbacks) {
                                        for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
                                            var fileCallback = callbacks_1[_i];
                                            fileCallback(fileName, FileWatcherEventKind.Changed);
                                        }
                                    }
                                });
                                watcher.referenceCount = 0;
                                dirWatchers.set(dirPath, watcher);
                                return watcher;
                            }
                        }
                        function fsWatchFile(fileName, callback, pollingInterval) {
                            _fs.watchFile(fileName, { persistent: true, interval: pollingInterval || 250 }, fileChanged);
                            var eventKind;
                            return {
                                close: function () { return _fs.unwatchFile(fileName, fileChanged); }
                            };
                            function fileChanged(curr, prev) {
                                // previous event kind check is to ensure we recongnize the file as previously also missing when it is restored or renamed twice (that is it disappears and reappears)
                                // In such case, prevTime returned is same as prev time of event when file was deleted as per node documentation
                                var isPreviouslyDeleted = +prev.mtime === 0 || eventKind === FileWatcherEventKind.Deleted;
                                if (+curr.mtime === 0) {
                                    if (isPreviouslyDeleted) {
                                        // Already deleted file, no need to callback again
                                        return;
                                    }
                                    eventKind = FileWatcherEventKind.Deleted;
                                }
                                else if (isPreviouslyDeleted) {
                                    eventKind = FileWatcherEventKind.Created;
                                }
                                // If there is no change in modified time, ignore the event
                                else if (+curr.mtime === +prev.mtime) {
                                    return;
                                }
                                else {
                                    // File changed
                                    eventKind = FileWatcherEventKind.Changed;
                                }
                                callback(fileName, eventKind);
                            }
                        }
                        function createFileWatcherCallback(callback) {
                            return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
                        }
                        function createFsWatchCallbackForFileWatcherCallback(fileName, callback) {
                            return function (eventName) {
                                if (eventName === "rename") {
                                    callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
                                }
                                else {
                                    // Change
                                    callback(fileName, FileWatcherEventKind.Changed);
                                }
                            };
                        }
                        function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback) {
                            return function (eventName, relativeFileName) {
                                // In watchDirectory we only care about adding and removing files (when event name is
                                // "rename"); changes made within files are handled by corresponding fileWatchers (when
                                // event name is "change")
                                if (eventName === "rename") {
                                    // When deleting a file, the passed baseFileName is null
                                    callback(!relativeFileName ? directoryName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName)));
                                }
                            };
                        }
                        function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingWatchFile, pollingInterval) {
                            var options;
                            /** Watcher for the file system entry depending on whether it is missing or present */
                            var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
                                watchMissingFileSystemEntry() :
                                watchPresentFileSystemEntry();
                            return {
                                close: function () {
                                    // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
                                    watcher.close();
                                    watcher = undefined;
                                }
                            };
                            /**
                             * Invoke the callback with rename and update the watcher if not closed
                             * @param createWatcher
                             */
                            function invokeCallbackAndUpdateWatcher(createWatcher) {
                                // Call the callback for current directory
                                callback("rename", "");
                                // If watcher is not closed, update it
                                if (watcher) {
                                    watcher.close();
                                    watcher = createWatcher();
                                }
                            }
                            /**
                             * Watch the file or directory that is currently present
                             * and when the watched file or directory is deleted, switch to missing file system entry watcher
                             */
                            function watchPresentFileSystemEntry() {
                                // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                                // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                                if (options === undefined) {
                                    if (isNode4OrLater && (process.platform === "win32" || process.platform === "darwin")) {
                                        options = { persistent: true, recursive: !!recursive };
                                    }
                                    else {
                                        options = { persistent: true };
                                    }
                                }
                                try {
                                    var presentWatcher = _fs.watch(fileOrDirectory, options, callback);
                                    // Watch the missing file or directory or error
                                    presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); });
                                    return presentWatcher;
                                }
                                catch (e) {
                                    // Catch the exception and use polling instead
                                    // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
                                    // so instead of throwing error, use fs.watchFile
                                    return watchPresentFileSystemEntryWithFsWatchFile();
                                }
                            }
                            /**
                             * Watch the file or directory using fs.watchFile since fs.watch threw exception
                             * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
                             */
                            function watchPresentFileSystemEntryWithFsWatchFile() {
                                return fallbackPollingWatchFile(fileOrDirectory, createFileWatcherCallback(callback), pollingInterval);
                            }
                            /**
                             * Watch the file or directory that is missing
                             * and switch to existing file or directory when the missing filesystem entry is created
                             */
                            function watchMissingFileSystemEntry() {
                                return fallbackPollingWatchFile(fileOrDirectory, function (_fileName, eventKind) {
                                    if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
                                        // Call the callback for current file or directory
                                        // For now it could be callback for the inner directory creation,
                                        // but just return current directory, better than current no-op
                                        invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry);
                                    }
                                }, pollingInterval);
                            }
                        }
                        function watchFileUsingFsWatch(fileName, callback, pollingInterval) {
                            return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback), /*recursive*/ false, fsWatchFile, pollingInterval);
                        }
                        function createWatchFileUsingDynamicWatchFile(watchFile) {
                            return function (fileName, callback, pollingInterval) { return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback), /*recursive*/ false, watchFile, pollingInterval); };
                        }
                        function fsWatchDirectory(directoryName, callback, recursive) {
                            return fsWatch(directoryName, 1 /* Directory */, callback, !!recursive, fsWatchFile);
                        }
                        function watchDirectoryUsingFsWatch(directoryName, callback, recursive) {
                            return fsWatchDirectory(directoryName, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive);
                        }
                        function createWatchDirectoryUsing(fsWatchFile) {
                            return function (directoryName, callback) { return fsWatchFile(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium); };
                        }
                        function readFile(fileName, _encoding) {
                            if (!fileExists(fileName)) {
                                return undefined;
                            }
                            var buffer = _fs.readFileSync(fileName);
                            var len = buffer.length;
                            if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
                                // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
                                // flip all byte pairs and treat as little endian.
                                len &= ~1; // Round down to a multiple of 2
                                for (var i = 0; i < len; i += 2) {
                                    var temp = buffer[i];
                                    buffer[i] = buffer[i + 1];
                                    buffer[i + 1] = temp;
                                }
                                return buffer.toString("utf16le", 2);
                            }
                            if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) {
                                // Little endian UTF-16 byte order mark detected
                                return buffer.toString("utf16le", 2);
                            }
                            if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
                                // UTF-8 byte order mark detected
                                return buffer.toString("utf8", 3);
                            }
                            // Default is UTF-8 with no byte order mark
                            return buffer.toString("utf8");
                        }
                        function writeFile(fileName, data, writeByteOrderMark) {
                            // If a BOM is required, emit one
                            if (writeByteOrderMark) {
                                data = byteOrderMarkIndicator + data;
                            }
                            var fd;
                            try {
                                fd = _fs.openSync(fileName, "w");
                                _fs.writeSync(fd, data, /*position*/ undefined, "utf8");
                            }
                            finally {
                                if (fd !== undefined) {
                                    _fs.closeSync(fd);
                                }
                            }
                        }
                        function getAccessibleFileSystemEntries(path) {
                            try {
                                var entries = _fs.readdirSync(path || ".").sort();
                                var files = [];
                                var directories = [];
                                for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
                                    var entry = entries_2[_i];
                                    // This is necessary because on some file system node fails to exclude
                                    // "." and "..". See https://github.com/nodejs/node/issues/4002
                                    if (entry === "." || entry === "..") {
                                        continue;
                                    }
                                    var name = ts.combinePaths(path, entry);
                                    var stat = void 0;
                                    try {
                                        stat = _fs.statSync(name);
                                    }
                                    catch (e) {
                                        continue;
                                    }
                                    if (stat.isFile()) {
                                        files.push(entry);
                                    }
                                    else if (stat.isDirectory()) {
                                        directories.push(entry);
                                    }
                                }
                                return { files: files, directories: directories };
                            }
                            catch (e) {
                                return ts.emptyFileSystemEntries;
                            }
                        }
                        function readDirectory(path, extensions, excludes, includes, depth) {
                            return ts.matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
                        }
                        function fileSystemEntryExists(path, entryKind) {
                            try {
                                var stat = _fs.statSync(path);
                                switch (entryKind) {
                                    case 0 /* File */: return stat.isFile();
                                    case 1 /* Directory */: return stat.isDirectory();
                                    default: return false;
                                }
                            }
                            catch (e) {
                                return false;
                            }
                        }
                        function fileExists(path) {
                            return fileSystemEntryExists(path, 0 /* File */);
                        }
                        function directoryExists(path) {
                            return fileSystemEntryExists(path, 1 /* Directory */);
                        }
                        function getDirectories(path) {
                            return ts.filter(_fs.readdirSync(path), function (dir) { return fileSystemEntryExists(ts.combinePaths(path, dir), 1 /* Directory */); });
                        }
                        function realpath(path) {
                            try {
                                return _fs.realpathSync(path);
                            }
                            catch (_a) {
                                return path;
                            }
                        }
                        function getModifiedTime(path) {
                            try {
                                return _fs.statSync(path).mtime;
                            }
                            catch (e) {
                                return undefined;
                            }
                        }
                        function setModifiedTime(path, time) {
                            try {
                                _fs.utimesSync(path, time, time);
                            }
                            catch (e) {
                                return;
                            }
                        }
                        function deleteFile(path) {
                            try {
                                return _fs.unlinkSync(path);
                            }
                            catch (e) {
                                return;
                            }
                        }
                        function createSHA256Hash(data) {
                            var hash = _crypto.createHash("sha256");
                            hash.update(data);
                            return hash.digest("hex");
                        }
                    }
                    function getChakraSystem() {
                        var realpath = ChakraHost.realpath && (function (path) { return ChakraHost.realpath(path); });
                        return {
                            newLine: ChakraHost.newLine || "\r\n",
                            args: ChakraHost.args,
                            useCaseSensitiveFileNames: !!ChakraHost.useCaseSensitiveFileNames,
                            write: ChakraHost.echo,
                            readFile: function (path, _encoding) {
                                // encoding is automatically handled by the implementation in ChakraHost
                                return ChakraHost.readFile(path);
                            },
                            writeFile: function (path, data, writeByteOrderMark) {
                                // If a BOM is required, emit one
                                if (writeByteOrderMark) {
                                    data = byteOrderMarkIndicator + data;
                                }
                                ChakraHost.writeFile(path, data);
                            },
                            resolvePath: ChakraHost.resolvePath,
                            fileExists: ChakraHost.fileExists,
                            deleteFile: ChakraHost.deleteFile,
                            getModifiedTime: ChakraHost.getModifiedTime,
                            setModifiedTime: ChakraHost.setModifiedTime,
                            directoryExists: ChakraHost.directoryExists,
                            createDirectory: ChakraHost.createDirectory,
                            getExecutingFilePath: function () { return ChakraHost.executingFile; },
                            getCurrentDirectory: function () { return ChakraHost.currentDirectory; },
                            getDirectories: ChakraHost.getDirectories,
                            getEnvironmentVariable: ChakraHost.getEnvironmentVariable || (function () { return ""; }),
                            readDirectory: function (path, extensions, excludes, includes, _depth) {
                                var pattern = ts.getFileMatcherPatterns(path, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory);
                                return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern);
                            },
                            exit: ChakraHost.quit,
                            realpath: realpath
                        };
                    }
                    function recursiveCreateDirectory(directoryPath, sys) {
                        var basePath = ts.getDirectoryPath(directoryPath);
                        var shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
                        if (shouldCreateParent) {
                            recursiveCreateDirectory(basePath, sys);
                        }
                        if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
                            sys.createDirectory(directoryPath);
                        }
                    }
                    var sys;
                    if (typeof ChakraHost !== "undefined") {
                        sys = getChakraSystem();
                    }
                    else if (typeof process !== "undefined" && nextTick && !browser$1 && typeof commonjsRequire !== "undefined") {
                        // process and process.nextTick checks if current environment is node-like
                        // process.browser check excludes webpack and browserify
                        sys = getNodeSystem();
                    }
                    if (sys) {
                        // patch writefile to create folder before writing the file
                        var originalWriteFile_1 = sys.writeFile;
                        sys.writeFile = function (path, data, writeBom) {
                            var directoryPath = ts.getDirectoryPath(ts.normalizeSlashes(path));
                            if (directoryPath && !sys.directoryExists(directoryPath)) {
                                recursiveCreateDirectory(directoryPath, sys);
                            }
                            originalWriteFile_1.call(sys, path, data, writeBom);
                        };
                    }
                    return sys;
                })();
                if (ts.sys && ts.sys.getEnvironmentVariable) {
                    setCustomPollingValues(ts.sys);
                    ts.Debug.currentAssertionLevel = /^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV"))
                        ? 1 /* Normal */
                        : 0 /* None */;
                }
                if (ts.sys && ts.sys.debugMode) {
                    ts.Debug.isDebugging = true;
                }
            })(ts || (ts = {}));
            // <auto-generated />
            // generated from './diagnosticInformationMap.generated.ts' by 'src/compiler'
            /* @internal */
            var ts;
            (function (ts) {
                function diag(code, category, key, message, reportsUnnecessary) {
                    return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary };
                }
                // tslint:disable-next-line variable-name
                ts.Diagnostics = {
                    Unterminated_string_literal: diag(1002, ts.DiagnosticCategory.Error, "Unterminated_string_literal_1002", "Unterminated string literal."),
                    Identifier_expected: diag(1003, ts.DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."),
                    _0_expected: diag(1005, ts.DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."),
                    A_file_cannot_have_a_reference_to_itself: diag(1006, ts.DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."),
                    Trailing_comma_not_allowed: diag(1009, ts.DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."),
                    Asterisk_Slash_expected: diag(1010, ts.DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."),
                    An_element_access_expression_should_take_an_argument: diag(1011, ts.DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."),
                    Unexpected_token: diag(1012, ts.DiagnosticCategory.Error, "Unexpected_token_1012", "Unexpected token."),
                    A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, ts.DiagnosticCategory.Error, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."),
                    A_rest_parameter_must_be_last_in_a_parameter_list: diag(1014, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."),
                    Parameter_cannot_have_question_mark_and_initializer: diag(1015, ts.DiagnosticCategory.Error, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."),
                    A_required_parameter_cannot_follow_an_optional_parameter: diag(1016, ts.DiagnosticCategory.Error, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."),
                    An_index_signature_cannot_have_a_rest_parameter: diag(1017, ts.DiagnosticCategory.Error, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."),
                    An_index_signature_parameter_cannot_have_an_accessibility_modifier: diag(1018, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."),
                    An_index_signature_parameter_cannot_have_a_question_mark: diag(1019, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."),
                    An_index_signature_parameter_cannot_have_an_initializer: diag(1020, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."),
                    An_index_signature_must_have_a_type_annotation: diag(1021, ts.DiagnosticCategory.Error, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."),
                    An_index_signature_parameter_must_have_a_type_annotation: diag(1022, ts.DiagnosticCategory.Error, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."),
                    An_index_signature_parameter_type_must_be_string_or_number: diag(1023, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_or_number_1023", "An index signature parameter type must be 'string' or 'number'."),
                    readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: diag(1024, ts.DiagnosticCategory.Error, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."),
                    Accessibility_modifier_already_seen: diag(1028, ts.DiagnosticCategory.Error, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."),
                    _0_modifier_must_precede_1_modifier: diag(1029, ts.DiagnosticCategory.Error, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."),
                    _0_modifier_already_seen: diag(1030, ts.DiagnosticCategory.Error, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."),
                    _0_modifier_cannot_appear_on_a_class_element: diag(1031, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_class_element_1031", "'{0}' modifier cannot appear on a class element."),
                    super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, ts.DiagnosticCategory.Error, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."),
                    Only_ambient_modules_can_use_quoted_names: diag(1035, ts.DiagnosticCategory.Error, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."),
                    Statements_are_not_allowed_in_ambient_contexts: diag(1036, ts.DiagnosticCategory.Error, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."),
                    A_declare_modifier_cannot_be_used_in_an_already_ambient_context: diag(1038, ts.DiagnosticCategory.Error, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."),
                    Initializers_are_not_allowed_in_ambient_contexts: diag(1039, ts.DiagnosticCategory.Error, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."),
                    _0_modifier_cannot_be_used_in_an_ambient_context: diag(1040, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."),
                    _0_modifier_cannot_be_used_with_a_class_declaration: diag(1041, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_class_declaration_1041", "'{0}' modifier cannot be used with a class declaration."),
                    _0_modifier_cannot_be_used_here: diag(1042, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."),
                    _0_modifier_cannot_appear_on_a_data_property: diag(1043, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_data_property_1043", "'{0}' modifier cannot appear on a data property."),
                    _0_modifier_cannot_appear_on_a_module_or_namespace_element: diag(1044, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."),
                    A_0_modifier_cannot_be_used_with_an_interface_declaration: diag(1045, ts.DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_interface_declaration_1045", "A '{0}' modifier cannot be used with an interface declaration."),
                    A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: diag(1046, ts.DiagnosticCategory.Error, "A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file_1046", "A 'declare' modifier is required for a top level declaration in a .d.ts file."),
                    A_rest_parameter_cannot_be_optional: diag(1047, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."),
                    A_rest_parameter_cannot_have_an_initializer: diag(1048, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."),
                    A_set_accessor_must_have_exactly_one_parameter: diag(1049, ts.DiagnosticCategory.Error, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."),
                    A_set_accessor_cannot_have_an_optional_parameter: diag(1051, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."),
                    A_set_accessor_parameter_cannot_have_an_initializer: diag(1052, ts.DiagnosticCategory.Error, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."),
                    A_set_accessor_cannot_have_rest_parameter: diag(1053, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."),
                    A_get_accessor_cannot_have_parameters: diag(1054, ts.DiagnosticCategory.Error, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."),
                    Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: diag(1055, ts.DiagnosticCategory.Error, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Prom_1055", "Type '{0}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value."),
                    Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: diag(1056, ts.DiagnosticCategory.Error, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."),
                    An_async_function_or_method_must_have_a_valid_awaitable_return_type: diag(1057, ts.DiagnosticCategory.Error, "An_async_function_or_method_must_have_a_valid_awaitable_return_type_1057", "An async function or method must have a valid awaitable return type."),
                    The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1058, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."),
                    A_promise_must_have_a_then_method: diag(1059, ts.DiagnosticCategory.Error, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."),
                    The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: diag(1060, ts.DiagnosticCategory.Error, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."),
                    Enum_member_must_have_initializer: diag(1061, ts.DiagnosticCategory.Error, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."),
                    Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, ts.DiagnosticCategory.Error, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
                    An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
                    The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1064, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1064", "The return type of an async function or method must be the global Promise<T> type."),
                    In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, ts.DiagnosticCategory.Error, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
                    Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, ts.DiagnosticCategory.Error, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
                    Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, ts.DiagnosticCategory.Error, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
                    _0_modifier_cannot_appear_on_a_type_member: diag(1070, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."),
                    _0_modifier_cannot_appear_on_an_index_signature: diag(1071, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."),
                    A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, ts.DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."),
                    Invalid_reference_directive_syntax: diag(1084, ts.DiagnosticCategory.Error, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."),
                    Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, ts.DiagnosticCategory.Error, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."),
                    An_accessor_cannot_be_declared_in_an_ambient_context: diag(1086, ts.DiagnosticCategory.Error, "An_accessor_cannot_be_declared_in_an_ambient_context_1086", "An accessor cannot be declared in an ambient context."),
                    _0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."),
                    _0_modifier_cannot_appear_on_a_parameter: diag(1090, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."),
                    Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."),
                    Type_parameters_cannot_appear_on_a_constructor_declaration: diag(1092, ts.DiagnosticCategory.Error, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."),
                    Type_annotation_cannot_appear_on_a_constructor_declaration: diag(1093, ts.DiagnosticCategory.Error, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."),
                    An_accessor_cannot_have_type_parameters: diag(1094, ts.DiagnosticCategory.Error, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."),
                    A_set_accessor_cannot_have_a_return_type_annotation: diag(1095, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."),
                    An_index_signature_must_have_exactly_one_parameter: diag(1096, ts.DiagnosticCategory.Error, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."),
                    _0_list_cannot_be_empty: diag(1097, ts.DiagnosticCategory.Error, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."),
                    Type_parameter_list_cannot_be_empty: diag(1098, ts.DiagnosticCategory.Error, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."),
                    Type_argument_list_cannot_be_empty: diag(1099, ts.DiagnosticCategory.Error, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."),
                    Invalid_use_of_0_in_strict_mode: diag(1100, ts.DiagnosticCategory.Error, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."),
                    with_statements_are_not_allowed_in_strict_mode: diag(1101, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."),
                    delete_cannot_be_called_on_an_identifier_in_strict_mode: diag(1102, ts.DiagnosticCategory.Error, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."),
                    A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator: diag(1103, ts.DiagnosticCategory.Error, "A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator_1103", "A 'for-await-of' statement is only allowed within an async function or async generator."),
                    A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: diag(1104, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."),
                    A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: diag(1105, ts.DiagnosticCategory.Error, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."),
                    Jump_target_cannot_cross_function_boundary: diag(1107, ts.DiagnosticCategory.Error, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."),
                    A_return_statement_can_only_be_used_within_a_function_body: diag(1108, ts.DiagnosticCategory.Error, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."),
                    Expression_expected: diag(1109, ts.DiagnosticCategory.Error, "Expression_expected_1109", "Expression expected."),
                    Type_expected: diag(1110, ts.DiagnosticCategory.Error, "Type_expected_1110", "Type expected."),
                    A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, ts.DiagnosticCategory.Error, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."),
                    Duplicate_label_0: diag(1114, ts.DiagnosticCategory.Error, "Duplicate_label_0_1114", "Duplicate label '{0}'."),
                    A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."),
                    A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, ts.DiagnosticCategory.Error, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."),
                    An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: diag(1117, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode_1117", "An object literal cannot have multiple properties with the same name in strict mode."),
                    An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."),
                    An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."),
                    An_export_assignment_cannot_have_modifiers: diag(1120, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."),
                    Octal_literals_are_not_allowed_in_strict_mode: diag(1121, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."),
                    Variable_declaration_list_cannot_be_empty: diag(1123, ts.DiagnosticCategory.Error, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."),
                    Digit_expected: diag(1124, ts.DiagnosticCategory.Error, "Digit_expected_1124", "Digit expected."),
                    Hexadecimal_digit_expected: diag(1125, ts.DiagnosticCategory.Error, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."),
                    Unexpected_end_of_text: diag(1126, ts.DiagnosticCategory.Error, "Unexpected_end_of_text_1126", "Unexpected end of text."),
                    Invalid_character: diag(1127, ts.DiagnosticCategory.Error, "Invalid_character_1127", "Invalid character."),
                    Declaration_or_statement_expected: diag(1128, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_1128", "Declaration or statement expected."),
                    Statement_expected: diag(1129, ts.DiagnosticCategory.Error, "Statement_expected_1129", "Statement expected."),
                    case_or_default_expected: diag(1130, ts.DiagnosticCategory.Error, "case_or_default_expected_1130", "'case' or 'default' expected."),
                    Property_or_signature_expected: diag(1131, ts.DiagnosticCategory.Error, "Property_or_signature_expected_1131", "Property or signature expected."),
                    Enum_member_expected: diag(1132, ts.DiagnosticCategory.Error, "Enum_member_expected_1132", "Enum member expected."),
                    Variable_declaration_expected: diag(1134, ts.DiagnosticCategory.Error, "Variable_declaration_expected_1134", "Variable declaration expected."),
                    Argument_expression_expected: diag(1135, ts.DiagnosticCategory.Error, "Argument_expression_expected_1135", "Argument expression expected."),
                    Property_assignment_expected: diag(1136, ts.DiagnosticCategory.Error, "Property_assignment_expected_1136", "Property assignment expected."),
                    Expression_or_comma_expected: diag(1137, ts.DiagnosticCategory.Error, "Expression_or_comma_expected_1137", "Expression or comma expected."),
                    Parameter_declaration_expected: diag(1138, ts.DiagnosticCategory.Error, "Parameter_declaration_expected_1138", "Parameter declaration expected."),
                    Type_parameter_declaration_expected: diag(1139, ts.DiagnosticCategory.Error, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."),
                    Type_argument_expected: diag(1140, ts.DiagnosticCategory.Error, "Type_argument_expected_1140", "Type argument expected."),
                    String_literal_expected: diag(1141, ts.DiagnosticCategory.Error, "String_literal_expected_1141", "String literal expected."),
                    Line_break_not_permitted_here: diag(1142, ts.DiagnosticCategory.Error, "Line_break_not_permitted_here_1142", "Line break not permitted here."),
                    or_expected: diag(1144, ts.DiagnosticCategory.Error, "or_expected_1144", "'{' or ';' expected."),
                    Declaration_expected: diag(1146, ts.DiagnosticCategory.Error, "Declaration_expected_1146", "Declaration expected."),
                    Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, ts.DiagnosticCategory.Error, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."),
                    Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, ts.DiagnosticCategory.Error, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."),
                    File_name_0_differs_from_already_included_file_name_1_only_in_casing: diag(1149, ts.DiagnosticCategory.Error, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."),
                    new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: diag(1150, ts.DiagnosticCategory.Error, "new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead_1150", "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead."),
                    const_declarations_must_be_initialized: diag(1155, ts.DiagnosticCategory.Error, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."),
                    const_declarations_can_only_be_declared_inside_a_block: diag(1156, ts.DiagnosticCategory.Error, "const_declarations_can_only_be_declared_inside_a_block_1156", "'const' declarations can only be declared inside a block."),
                    let_declarations_can_only_be_declared_inside_a_block: diag(1157, ts.DiagnosticCategory.Error, "let_declarations_can_only_be_declared_inside_a_block_1157", "'let' declarations can only be declared inside a block."),
                    Unterminated_template_literal: diag(1160, ts.DiagnosticCategory.Error, "Unterminated_template_literal_1160", "Unterminated template literal."),
                    Unterminated_regular_expression_literal: diag(1161, ts.DiagnosticCategory.Error, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."),
                    An_object_member_cannot_be_declared_optional: diag(1162, ts.DiagnosticCategory.Error, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."),
                    A_yield_expression_is_only_allowed_in_a_generator_body: diag(1163, ts.DiagnosticCategory.Error, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."),
                    Computed_property_names_are_not_allowed_in_enums: diag(1164, ts.DiagnosticCategory.Error, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."),
                    A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1165, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."),
                    A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1166, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_1166", "A computed property name in a class property declaration must refer to an expression whose type is a literal type or a 'unique symbol' type."),
                    A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1168, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."),
                    A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1169, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."),
                    A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1170, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."),
                    A_comma_expression_is_not_allowed_in_a_computed_property_name: diag(1171, ts.DiagnosticCategory.Error, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."),
                    extends_clause_already_seen: diag(1172, ts.DiagnosticCategory.Error, "extends_clause_already_seen_1172", "'extends' clause already seen."),
                    extends_clause_must_precede_implements_clause: diag(1173, ts.DiagnosticCategory.Error, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."),
                    Classes_can_only_extend_a_single_class: diag(1174, ts.DiagnosticCategory.Error, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."),
                    implements_clause_already_seen: diag(1175, ts.DiagnosticCategory.Error, "implements_clause_already_seen_1175", "'implements' clause already seen."),
                    Interface_declaration_cannot_have_implements_clause: diag(1176, ts.DiagnosticCategory.Error, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."),
                    Binary_digit_expected: diag(1177, ts.DiagnosticCategory.Error, "Binary_digit_expected_1177", "Binary digit expected."),
                    Octal_digit_expected: diag(1178, ts.DiagnosticCategory.Error, "Octal_digit_expected_1178", "Octal digit expected."),
                    Unexpected_token_expected: diag(1179, ts.DiagnosticCategory.Error, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."),
                    Property_destructuring_pattern_expected: diag(1180, ts.DiagnosticCategory.Error, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."),
                    Array_element_destructuring_pattern_expected: diag(1181, ts.DiagnosticCategory.Error, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."),
                    A_destructuring_declaration_must_have_an_initializer: diag(1182, ts.DiagnosticCategory.Error, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."),
                    An_implementation_cannot_be_declared_in_ambient_contexts: diag(1183, ts.DiagnosticCategory.Error, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."),
                    Modifiers_cannot_appear_here: diag(1184, ts.DiagnosticCategory.Error, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."),
                    Merge_conflict_marker_encountered: diag(1185, ts.DiagnosticCategory.Error, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."),
                    A_rest_element_cannot_have_an_initializer: diag(1186, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."),
                    A_parameter_property_may_not_be_declared_using_a_binding_pattern: diag(1187, ts.DiagnosticCategory.Error, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."),
                    Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: diag(1188, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."),
                    The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: diag(1189, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."),
                    The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: diag(1190, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."),
                    An_import_declaration_cannot_have_modifiers: diag(1191, ts.DiagnosticCategory.Error, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."),
                    Module_0_has_no_default_export: diag(1192, ts.DiagnosticCategory.Error, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."),
                    An_export_declaration_cannot_have_modifiers: diag(1193, ts.DiagnosticCategory.Error, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."),
                    Export_declarations_are_not_permitted_in_a_namespace: diag(1194, ts.DiagnosticCategory.Error, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."),
                    Catch_clause_variable_cannot_have_a_type_annotation: diag(1196, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_a_type_annotation_1196", "Catch clause variable cannot have a type annotation."),
                    Catch_clause_variable_cannot_have_an_initializer: diag(1197, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."),
                    An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, ts.DiagnosticCategory.Error, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."),
                    Unterminated_Unicode_escape_sequence: diag(1199, ts.DiagnosticCategory.Error, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."),
                    Line_terminator_not_permitted_before_arrow: diag(1200, ts.DiagnosticCategory.Error, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."),
                    Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(1202, ts.DiagnosticCategory.Error, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead."),
                    Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: diag(1203, ts.DiagnosticCategory.Error, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."),
                    Cannot_re_export_a_type_when_the_isolatedModules_flag_is_provided: diag(1205, ts.DiagnosticCategory.Error, "Cannot_re_export_a_type_when_the_isolatedModules_flag_is_provided_1205", "Cannot re-export a type when the '--isolatedModules' flag is provided."),
                    Decorators_are_not_valid_here: diag(1206, ts.DiagnosticCategory.Error, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."),
                    Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, ts.DiagnosticCategory.Error, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."),
                    Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided: diag(1208, ts.DiagnosticCategory.Error, "Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided_1208", "Cannot compile namespaces when the '--isolatedModules' flag is provided."),
                    Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: diag(1210, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode_1210", "Invalid use of '{0}'. Class definitions are automatically in strict mode."),
                    A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, ts.DiagnosticCategory.Error, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."),
                    Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."),
                    Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: diag(1213, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."),
                    Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: diag(1214, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."),
                    Invalid_use_of_0_Modules_are_automatically_in_strict_mode: diag(1215, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."),
                    Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: diag(1216, ts.DiagnosticCategory.Error, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."),
                    Export_assignment_is_not_supported_when_module_flag_is_system: diag(1218, ts.DiagnosticCategory.Error, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."),
                    Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning: diag(1219, ts.DiagnosticCategory.Error, "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning."),
                    Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher: diag(1220, ts.DiagnosticCategory.Error, "Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher_1220", "Generators are only available when targeting ECMAScript 2015 or higher."),
                    Generators_are_not_allowed_in_an_ambient_context: diag(1221, ts.DiagnosticCategory.Error, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."),
                    An_overload_signature_cannot_be_declared_as_a_generator: diag(1222, ts.DiagnosticCategory.Error, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."),
                    _0_tag_already_specified: diag(1223, ts.DiagnosticCategory.Error, "_0_tag_already_specified_1223", "'{0}' tag already specified."),
                    Signature_0_must_be_a_type_predicate: diag(1224, ts.DiagnosticCategory.Error, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."),
                    Cannot_find_parameter_0: diag(1225, ts.DiagnosticCategory.Error, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."),
                    Type_predicate_0_is_not_assignable_to_1: diag(1226, ts.DiagnosticCategory.Error, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."),
                    Parameter_0_is_not_in_the_same_position_as_parameter_1: diag(1227, ts.DiagnosticCategory.Error, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."),
                    A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: diag(1228, ts.DiagnosticCategory.Error, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."),
                    A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."),
                    A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."),
                    An_export_assignment_can_only_be_used_in_a_module: diag(1231, ts.DiagnosticCategory.Error, "An_export_assignment_can_only_be_used_in_a_module_1231", "An export assignment can only be used in a module."),
                    An_import_declaration_can_only_be_used_in_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", "An import declaration can only be used in a namespace or module."),
                    An_export_declaration_can_only_be_used_in_a_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_in_a_module_1233", "An export declaration can only be used in a module."),
                    An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts.DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."),
                    A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", "A namespace declaration is only allowed in a namespace or module."),
                    The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts.DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."),
                    The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts.DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."),
                    Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."),
                    Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: diag(1239, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."),
                    Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: diag(1240, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."),
                    Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: diag(1241, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."),
                    abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: diag(1242, ts.DiagnosticCategory.Error, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."),
                    _0_modifier_cannot_be_used_with_1_modifier: diag(1243, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."),
                    Abstract_methods_can_only_appear_within_an_abstract_class: diag(1244, ts.DiagnosticCategory.Error, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."),
                    Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: diag(1245, ts.DiagnosticCategory.Error, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."),
                    An_interface_property_cannot_have_an_initializer: diag(1246, ts.DiagnosticCategory.Error, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."),
                    A_type_literal_property_cannot_have_an_initializer: diag(1247, ts.DiagnosticCategory.Error, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."),
                    A_class_member_cannot_have_the_0_keyword: diag(1248, ts.DiagnosticCategory.Error, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."),
                    A_decorator_can_only_decorate_a_method_implementation_not_an_overload: diag(1249, ts.DiagnosticCategory.Error, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."),
                    Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."),
                    Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."),
                    Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."),
                    _0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag: diag(1253, ts.DiagnosticCategory.Error, "_0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag_1253", "'{0}' tag cannot be used independently as a top level JSDoc tag."),
                    A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, ts.DiagnosticCategory.Error, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."),
                    A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts.DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."),
                    A_rest_element_must_be_last_in_a_tuple_type: diag(1256, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_tuple_type_1256", "A rest element must be last in a tuple type."),
                    A_required_element_cannot_follow_an_optional_element: diag(1257, ts.DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."),
                    with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
                    await_expression_is_only_allowed_within_an_async_function: diag(1308, ts.DiagnosticCategory.Error, "await_expression_is_only_allowed_within_an_async_function_1308", "'await' expression is only allowed within an async function."),
                    can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: diag(1312, ts.DiagnosticCategory.Error, "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", "'=' can only be used in an object literal property inside a destructuring assignment."),
                    The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts.DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."),
                    Global_module_exports_may_only_appear_in_module_files: diag(1314, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."),
                    Global_module_exports_may_only_appear_in_declaration_files: diag(1315, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."),
                    Global_module_exports_may_only_appear_at_top_level: diag(1316, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."),
                    A_parameter_property_cannot_be_declared_using_a_rest_parameter: diag(1317, ts.DiagnosticCategory.Error, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."),
                    An_abstract_accessor_cannot_have_an_implementation: diag(1318, ts.DiagnosticCategory.Error, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."),
                    A_default_export_can_only_be_used_in_an_ECMAScript_style_module: diag(1319, ts.DiagnosticCategory.Error, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."),
                    Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts.DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."),
                    Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
                    Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
                    Dynamic_import_is_only_supported_when_module_flag_is_commonjs_or_esNext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_import_is_only_supported_when_module_flag_is_commonjs_or_esNext_1323", "Dynamic import is only supported when '--module' flag is 'commonjs' or 'esNext'."),
                    Dynamic_import_must_have_one_specifier_as_an_argument: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_import_must_have_one_specifier_as_an_argument_1324", "Dynamic import must have one specifier as an argument."),
                    Specifier_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Specifier_of_dynamic_import_cannot_be_spread_element_1325", "Specifier of dynamic import cannot be spread element."),
                    Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments"),
                    String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
                    Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."),
                    _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"),
                    A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: diag(1330, ts.DiagnosticCategory.Error, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."),
                    A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: diag(1331, ts.DiagnosticCategory.Error, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."),
                    A_variable_whose_type_is_a_unique_symbol_type_must_be_const: diag(1332, ts.DiagnosticCategory.Error, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."),
                    unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: diag(1333, ts.DiagnosticCategory.Error, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."),
                    unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: diag(1334, ts.DiagnosticCategory.Error, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."),
                    unique_symbol_types_are_not_allowed_here: diag(1335, ts.DiagnosticCategory.Error, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."),
                    An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead: diag(1336, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead_1336", "An index signature parameter type cannot be a type alias. Consider writing '[{0}: {1}]: {2}' instead."),
                    An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead: diag(1337, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead_1337", "An index signature parameter type cannot be a union type. Consider using a mapped object type instead."),
                    infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: diag(1338, ts.DiagnosticCategory.Error, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."),
                    Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
                    Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
                    Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
                    The_import_meta_meta_property_is_only_allowed_using_ESNext_for_the_target_and_module_compiler_options: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_using_ESNext_for_the_target_and_module_compiler_option_1343", "The 'import.meta' meta-property is only allowed using 'ESNext' for the 'target' and 'module' compiler options."),
                    A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
                    An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness"),
                    This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
                    use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, ts.DiagnosticCategory.Error, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."),
                    Non_simple_parameter_declared_here: diag(1348, ts.DiagnosticCategory.Error, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."),
                    use_strict_directive_used_here: diag(1349, ts.DiagnosticCategory.Error, "use_strict_directive_used_here_1349", "'use strict' directive used here."),
                    Print_the_final_configuration_instead_of_building: diag(1350, ts.DiagnosticCategory.Message, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."),
                    An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: diag(1351, ts.DiagnosticCategory.Error, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."),
                    A_bigint_literal_cannot_use_exponential_notation: diag(1352, ts.DiagnosticCategory.Error, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."),
                    A_bigint_literal_must_be_an_integer: diag(1353, ts.DiagnosticCategory.Error, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."),
                    readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: diag(1354, ts.DiagnosticCategory.Error, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."),
                    A_const_assertion_can_only_be_applied_to_a_string_number_boolean_array_or_object_literal: diag(1355, ts.DiagnosticCategory.Error, "A_const_assertion_can_only_be_applied_to_a_string_number_boolean_array_or_object_literal_1355", "A 'const' assertion can only be applied to a string, number, boolean, array, or object literal."),
                    Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
                    Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
                    Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
                    Circular_definition_of_import_alias_0: diag(2303, ts.DiagnosticCategory.Error, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."),
                    Cannot_find_name_0: diag(2304, ts.DiagnosticCategory.Error, "Cannot_find_name_0_2304", "Cannot find name '{0}'."),
                    Module_0_has_no_exported_member_1: diag(2305, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."),
                    File_0_is_not_a_module: diag(2306, ts.DiagnosticCategory.Error, "File_0_is_not_a_module_2306", "File '{0}' is not a module."),
                    Cannot_find_module_0: diag(2307, ts.DiagnosticCategory.Error, "Cannot_find_module_0_2307", "Cannot find module '{0}'."),
                    Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, ts.DiagnosticCategory.Error, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."),
                    An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."),
                    Type_0_recursively_references_itself_as_a_base_type: diag(2310, ts.DiagnosticCategory.Error, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."),
                    A_class_may_only_extend_another_class: diag(2311, ts.DiagnosticCategory.Error, "A_class_may_only_extend_another_class_2311", "A class may only extend another class."),
                    An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."),
                    Type_parameter_0_has_a_circular_constraint: diag(2313, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."),
                    Generic_type_0_requires_1_type_argument_s: diag(2314, ts.DiagnosticCategory.Error, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."),
                    Type_0_is_not_generic: diag(2315, ts.DiagnosticCategory.Error, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."),
                    Global_type_0_must_be_a_class_or_interface_type: diag(2316, ts.DiagnosticCategory.Error, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."),
                    Global_type_0_must_have_1_type_parameter_s: diag(2317, ts.DiagnosticCategory.Error, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."),
                    Cannot_find_global_type_0: diag(2318, ts.DiagnosticCategory.Error, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."),
                    Named_property_0_of_types_1_and_2_are_not_identical: diag(2319, ts.DiagnosticCategory.Error, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."),
                    Interface_0_cannot_simultaneously_extend_types_1_and_2: diag(2320, ts.DiagnosticCategory.Error, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."),
                    Excessive_stack_depth_comparing_types_0_and_1: diag(2321, ts.DiagnosticCategory.Error, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."),
                    Type_0_is_not_assignable_to_type_1: diag(2322, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."),
                    Cannot_redeclare_exported_variable_0: diag(2323, ts.DiagnosticCategory.Error, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."),
                    Property_0_is_missing_in_type_1: diag(2324, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."),
                    Property_0_is_private_in_type_1_but_not_in_type_2: diag(2325, ts.DiagnosticCategory.Error, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."),
                    Types_of_property_0_are_incompatible: diag(2326, ts.DiagnosticCategory.Error, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."),
                    Property_0_is_optional_in_type_1_but_required_in_type_2: diag(2327, ts.DiagnosticCategory.Error, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."),
                    Types_of_parameters_0_and_1_are_incompatible: diag(2328, ts.DiagnosticCategory.Error, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."),
                    Index_signature_is_missing_in_type_0: diag(2329, ts.DiagnosticCategory.Error, "Index_signature_is_missing_in_type_0_2329", "Index signature is missing in type '{0}'."),
                    Index_signatures_are_incompatible: diag(2330, ts.DiagnosticCategory.Error, "Index_signatures_are_incompatible_2330", "Index signatures are incompatible."),
                    this_cannot_be_referenced_in_a_module_or_namespace_body: diag(2331, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."),
                    this_cannot_be_referenced_in_current_location: diag(2332, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."),
                    this_cannot_be_referenced_in_constructor_arguments: diag(2333, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_constructor_arguments_2333", "'this' cannot be referenced in constructor arguments."),
                    this_cannot_be_referenced_in_a_static_property_initializer: diag(2334, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."),
                    super_can_only_be_referenced_in_a_derived_class: diag(2335, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."),
                    super_cannot_be_referenced_in_constructor_arguments: diag(2336, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."),
                    Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: diag(2337, ts.DiagnosticCategory.Error, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."),
                    super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: diag(2338, ts.DiagnosticCategory.Error, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."),
                    Property_0_does_not_exist_on_type_1: diag(2339, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."),
                    Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: diag(2340, ts.DiagnosticCategory.Error, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."),
                    Property_0_is_private_and_only_accessible_within_class_1: diag(2341, ts.DiagnosticCategory.Error, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."),
                    An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: diag(2342, ts.DiagnosticCategory.Error, "An_index_expression_argument_must_be_of_type_string_number_symbol_or_any_2342", "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'."),
                    This_syntax_requires_an_imported_helper_named_1_but_module_0_has_no_exported_member_1: diag(2343, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_but_module_0_has_no_exported_member_1_2343", "This syntax requires an imported helper named '{1}', but module '{0}' has no exported member '{1}'."),
                    Type_0_does_not_satisfy_the_constraint_1: diag(2344, ts.DiagnosticCategory.Error, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."),
                    Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."),
                    Call_target_does_not_contain_any_signatures: diag(2346, ts.DiagnosticCategory.Error, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."),
                    Untyped_function_calls_may_not_accept_type_arguments: diag(2347, ts.DiagnosticCategory.Error, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."),
                    Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, ts.DiagnosticCategory.Error, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"),
                    Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures: diag(2349, ts.DiagnosticCategory.Error, "Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatur_2349", "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures."),
                    Only_a_void_function_can_be_called_with_the_new_keyword: diag(2350, ts.DiagnosticCategory.Error, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."),
                    Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: diag(2351, ts.DiagnosticCategory.Error, "Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature_2351", "Cannot use 'new' with an expression whose type lacks a call or construct signature."),
                    Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: diag(2352, ts.DiagnosticCategory.Error, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."),
                    Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: diag(2353, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."),
                    This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: diag(2354, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."),
                    A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: diag(2355, ts.DiagnosticCategory.Error, "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'void' nor 'any' must return a value."),
                    An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2356, ts.DiagnosticCategory.Error, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."),
                    The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."),
                    The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."),
                    The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."),
                    The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'."),
                    The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter_2361", "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter."),
                    The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
                    The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
                    The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."),
                    Operator_0_cannot_be_applied_to_types_1_and_2: diag(2365, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."),
                    Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: diag(2366, ts.DiagnosticCategory.Error, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."),
                    This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap: diag(2367, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap_2367", "This condition will always return '{0}' since the types '{1}' and '{2}' have no overlap."),
                    Type_parameter_name_cannot_be_0: diag(2368, ts.DiagnosticCategory.Error, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."),
                    A_parameter_property_is_only_allowed_in_a_constructor_implementation: diag(2369, ts.DiagnosticCategory.Error, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."),
                    A_rest_parameter_must_be_of_an_array_type: diag(2370, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."),
                    A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: diag(2371, ts.DiagnosticCategory.Error, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."),
                    Parameter_0_cannot_be_referenced_in_its_initializer: diag(2372, ts.DiagnosticCategory.Error, "Parameter_0_cannot_be_referenced_in_its_initializer_2372", "Parameter '{0}' cannot be referenced in its initializer."),
                    Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts.DiagnosticCategory.Error, "Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it."),
                    Duplicate_string_index_signature: diag(2374, ts.DiagnosticCategory.Error, "Duplicate_string_index_signature_2374", "Duplicate string index signature."),
                    Duplicate_number_index_signature: diag(2375, ts.DiagnosticCategory.Error, "Duplicate_number_index_signature_2375", "Duplicate number index signature."),
                    A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties."),
                    Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts.DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."),
                    A_get_accessor_must_return_a_value: diag(2378, ts.DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."),
                    Getter_and_setter_accessors_do_not_agree_in_visibility: diag(2379, ts.DiagnosticCategory.Error, "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", "Getter and setter accessors do not agree in visibility."),
                    get_and_set_accessor_must_have_the_same_type: diag(2380, ts.DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_type_2380", "'get' and 'set' accessor must have the same type."),
                    A_signature_with_an_implementation_cannot_use_a_string_literal_type: diag(2381, ts.DiagnosticCategory.Error, "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", "A signature with an implementation cannot use a string literal type."),
                    Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: diag(2382, ts.DiagnosticCategory.Error, "Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature_2382", "Specialized overload signature is not assignable to any non-specialized signature."),
                    Overload_signatures_must_all_be_exported_or_non_exported: diag(2383, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."),
                    Overload_signatures_must_all_be_ambient_or_non_ambient: diag(2384, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."),
                    Overload_signatures_must_all_be_public_private_or_protected: diag(2385, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."),
                    Overload_signatures_must_all_be_optional_or_required: diag(2386, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."),
                    Function_overload_must_be_static: diag(2387, ts.DiagnosticCategory.Error, "Function_overload_must_be_static_2387", "Function overload must be static."),
                    Function_overload_must_not_be_static: diag(2388, ts.DiagnosticCategory.Error, "Function_overload_must_not_be_static_2388", "Function overload must not be static."),
                    Function_implementation_name_must_be_0: diag(2389, ts.DiagnosticCategory.Error, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."),
                    Constructor_implementation_is_missing: diag(2390, ts.DiagnosticCategory.Error, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."),
                    Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, ts.DiagnosticCategory.Error, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."),
                    Multiple_constructor_implementations_are_not_allowed: diag(2392, ts.DiagnosticCategory.Error, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."),
                    Duplicate_function_implementation: diag(2393, ts.DiagnosticCategory.Error, "Duplicate_function_implementation_2393", "Duplicate function implementation."),
                    This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, ts.DiagnosticCategory.Error, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."),
                    Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: diag(2395, ts.DiagnosticCategory.Error, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."),
                    Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: diag(2396, ts.DiagnosticCategory.Error, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."),
                    Declaration_name_conflicts_with_built_in_global_identifier_0: diag(2397, ts.DiagnosticCategory.Error, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."),
                    Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts.DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."),
                    Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."),
                    Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: diag(2401, ts.DiagnosticCategory.Error, "Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference_2401", "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference."),
                    Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts.DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."),
                    Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts.DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'."),
                    The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."),
                    The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: diag(2405, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."),
                    The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: diag(2406, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."),
                    The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: diag(2407, ts.DiagnosticCategory.Error, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."),
                    Setters_cannot_return_a_value: diag(2408, ts.DiagnosticCategory.Error, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."),
                    Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: diag(2409, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."),
                    The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: diag(2410, ts.DiagnosticCategory.Error, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."),
                    Property_0_of_type_1_is_not_assignable_to_string_index_type_2: diag(2411, ts.DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_string_index_type_2_2411", "Property '{0}' of type '{1}' is not assignable to string index type '{2}'."),
                    Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: diag(2412, ts.DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2_2412", "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'."),
                    Numeric_index_type_0_is_not_assignable_to_string_index_type_1: diag(2413, ts.DiagnosticCategory.Error, "Numeric_index_type_0_is_not_assignable_to_string_index_type_1_2413", "Numeric index type '{0}' is not assignable to string index type '{1}'."),
                    Class_name_cannot_be_0: diag(2414, ts.DiagnosticCategory.Error, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."),
                    Class_0_incorrectly_extends_base_class_1: diag(2415, ts.DiagnosticCategory.Error, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."),
                    Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."),
                    Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, ts.DiagnosticCategory.Error, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."),
                    Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, ts.DiagnosticCategory.Error, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."),
                    Class_0_incorrectly_implements_interface_1: diag(2420, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."),
                    A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."),
                    Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."),
                    Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: diag(2424, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_proper_2424", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property."),
                    Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2425, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."),
                    Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2426, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."),
                    Interface_name_cannot_be_0: diag(2427, ts.DiagnosticCategory.Error, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."),
                    All_declarations_of_0_must_have_identical_type_parameters: diag(2428, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."),
                    Interface_0_incorrectly_extends_interface_1: diag(2430, ts.DiagnosticCategory.Error, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."),
                    Enum_name_cannot_be_0: diag(2431, ts.DiagnosticCategory.Error, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."),
                    In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: diag(2432, ts.DiagnosticCategory.Error, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."),
                    A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: diag(2433, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."),
                    A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: diag(2434, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."),
                    Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: diag(2435, ts.DiagnosticCategory.Error, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."),
                    Ambient_module_declaration_cannot_specify_relative_module_name: diag(2436, ts.DiagnosticCategory.Error, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."),
                    Module_0_is_hidden_by_a_local_declaration_with_the_same_name: diag(2437, ts.DiagnosticCategory.Error, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."),
                    Import_name_cannot_be_0: diag(2438, ts.DiagnosticCategory.Error, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."),
                    Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: diag(2439, ts.DiagnosticCategory.Error, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."),
                    Import_declaration_conflicts_with_local_declaration_of_0: diag(2440, ts.DiagnosticCategory.Error, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."),
                    Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: diag(2441, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."),
                    Types_have_separate_declarations_of_a_private_property_0: diag(2442, ts.DiagnosticCategory.Error, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."),
                    Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: diag(2443, ts.DiagnosticCategory.Error, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."),
                    Property_0_is_protected_in_type_1_but_public_in_type_2: diag(2444, ts.DiagnosticCategory.Error, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."),
                    Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: diag(2445, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."),
                    Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: diag(2446, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'."),
                    The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: diag(2447, ts.DiagnosticCategory.Error, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."),
                    Block_scoped_variable_0_used_before_its_declaration: diag(2448, ts.DiagnosticCategory.Error, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."),
                    Class_0_used_before_its_declaration: diag(2449, ts.DiagnosticCategory.Error, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."),
                    Enum_0_used_before_its_declaration: diag(2450, ts.DiagnosticCategory.Error, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."),
                    Cannot_redeclare_block_scoped_variable_0: diag(2451, ts.DiagnosticCategory.Error, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."),
                    An_enum_member_cannot_have_a_numeric_name: diag(2452, ts.DiagnosticCategory.Error, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."),
                    The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: diag(2453, ts.DiagnosticCategory.Error, "The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_typ_2453", "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly."),
                    Variable_0_is_used_before_being_assigned: diag(2454, ts.DiagnosticCategory.Error, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."),
                    Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: diag(2455, ts.DiagnosticCategory.Error, "Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0_2455", "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'."),
                    Type_alias_0_circularly_references_itself: diag(2456, ts.DiagnosticCategory.Error, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."),
                    Type_alias_name_cannot_be_0: diag(2457, ts.DiagnosticCategory.Error, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."),
                    An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, ts.DiagnosticCategory.Error, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."),
                    Type_0_is_not_an_array_type: diag(2461, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."),
                    A_rest_element_must_be_last_in_a_destructuring_pattern: diag(2462, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."),
                    A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: diag(2463, ts.DiagnosticCategory.Error, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."),
                    A_computed_property_name_must_be_of_type_string_number_symbol_or_any: diag(2464, ts.DiagnosticCategory.Error, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."),
                    this_cannot_be_referenced_in_a_computed_property_name: diag(2465, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."),
                    super_cannot_be_referenced_in_a_computed_property_name: diag(2466, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."),
                    A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: diag(2467, ts.DiagnosticCategory.Error, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."),
                    Cannot_find_global_value_0: diag(2468, ts.DiagnosticCategory.Error, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."),
                    The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, ts.DiagnosticCategory.Error, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."),
                    Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: diag(2470, ts.DiagnosticCategory.Error, "Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object_2470", "'Symbol' reference does not refer to the global Symbol constructor object."),
                    A_computed_property_name_of_the_form_0_must_be_of_type_symbol: diag(2471, ts.DiagnosticCategory.Error, "A_computed_property_name_of_the_form_0_must_be_of_type_symbol_2471", "A computed property name of the form '{0}' must be of type 'symbol'."),
                    Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, ts.DiagnosticCategory.Error, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."),
                    Enum_declarations_must_all_be_const_or_non_const: diag(2473, ts.DiagnosticCategory.Error, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."),
                    const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, ts.DiagnosticCategory.Error, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."),
                    const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, ts.DiagnosticCategory.Error, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."),
                    A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, ts.DiagnosticCategory.Error, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."),
                    const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."),
                    const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: diag(2478, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."),
                    Property_0_does_not_exist_on_const_enum_1: diag(2479, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_const_enum_1_2479", "Property '{0}' does not exist on 'const' enum '{1}'."),
                    let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: diag(2480, ts.DiagnosticCategory.Error, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."),
                    Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: diag(2481, ts.DiagnosticCategory.Error, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."),
                    The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: diag(2483, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."),
                    Export_declaration_conflicts_with_exported_declaration_of_0: diag(2484, ts.DiagnosticCategory.Error, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."),
                    The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: diag(2487, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."),
                    Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2488, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."),
                    An_iterator_must_have_a_next_method: diag(2489, ts.DiagnosticCategory.Error, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."),
                    The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: diag(2490, ts.DiagnosticCategory.Error, "The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the 'next()' method of an iterator must have a 'value' property."),
                    The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: diag(2491, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."),
                    Cannot_redeclare_identifier_0_in_catch_clause: diag(2492, ts.DiagnosticCategory.Error, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."),
                    Tuple_type_0_of_length_1_has_no_element_at_index_2: diag(2493, ts.DiagnosticCategory.Error, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."),
                    Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: diag(2494, ts.DiagnosticCategory.Error, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."),
                    Type_0_is_not_an_array_type_or_a_string_type: diag(2495, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."),
                    The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: diag(2496, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression."),
                    This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: diag(2497, ts.DiagnosticCategory.Error, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."),
                    Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: diag(2498, ts.DiagnosticCategory.Error, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."),
                    An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2499, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."),
                    A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2500, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."),
                    A_rest_element_cannot_contain_a_binding_pattern: diag(2501, ts.DiagnosticCategory.Error, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."),
                    _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: diag(2502, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."),
                    Cannot_find_namespace_0: diag(2503, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."),
                    Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: diag(2504, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."),
                    A_generator_cannot_have_a_void_type_annotation: diag(2505, ts.DiagnosticCategory.Error, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."),
                    _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: diag(2506, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."),
                    Type_0_is_not_a_constructor_function_type: diag(2507, ts.DiagnosticCategory.Error, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."),
                    No_base_constructor_has_the_specified_number_of_type_arguments: diag(2508, ts.DiagnosticCategory.Error, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."),
                    Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2509, ts.DiagnosticCategory.Error, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."),
                    Base_constructors_must_all_have_the_same_return_type: diag(2510, ts.DiagnosticCategory.Error, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."),
                    Cannot_create_an_instance_of_an_abstract_class: diag(2511, ts.DiagnosticCategory.Error, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."),
                    Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."),
                    Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, ts.DiagnosticCategory.Error, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."),
                    Classes_containing_abstract_methods_must_be_marked_abstract: diag(2514, ts.DiagnosticCategory.Error, "Classes_containing_abstract_methods_must_be_marked_abstract_2514", "Classes containing abstract methods must be marked abstract."),
                    Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, ts.DiagnosticCategory.Error, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."),
                    All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, ts.DiagnosticCategory.Error, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."),
                    Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, ts.DiagnosticCategory.Error, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."),
                    A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, ts.DiagnosticCategory.Error, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."),
                    An_async_iterator_must_have_a_next_method: diag(2519, ts.DiagnosticCategory.Error, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."),
                    Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: diag(2520, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."),
                    Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: diag(2521, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions_2521", "Expression resolves to variable declaration '{0}' that compiler uses to support async functions."),
                    The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method: diag(2522, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_usi_2522", "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method."),
                    yield_expressions_cannot_be_used_in_a_parameter_initializer: diag(2523, ts.DiagnosticCategory.Error, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."),
                    await_expressions_cannot_be_used_in_a_parameter_initializer: diag(2524, ts.DiagnosticCategory.Error, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."),
                    Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: diag(2525, ts.DiagnosticCategory.Error, "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", "Initializer provides no value for this binding element and the binding element has no default value."),
                    A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: diag(2526, ts.DiagnosticCategory.Error, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."),
                    The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: diag(2527, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."),
                    A_module_cannot_have_multiple_default_exports: diag(2528, ts.DiagnosticCategory.Error, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."),
                    Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: diag(2529, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."),
                    Property_0_is_incompatible_with_index_signature: diag(2530, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."),
                    Object_is_possibly_null: diag(2531, ts.DiagnosticCategory.Error, "Object_is_possibly_null_2531", "Object is possibly 'null'."),
                    Object_is_possibly_undefined: diag(2532, ts.DiagnosticCategory.Error, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."),
                    Object_is_possibly_null_or_undefined: diag(2533, ts.DiagnosticCategory.Error, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."),
                    A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, ts.DiagnosticCategory.Error, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."),
                    Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, ts.DiagnosticCategory.Error, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."),
                    Type_0_cannot_be_used_to_index_type_1: diag(2536, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."),
                    Type_0_has_no_matching_index_signature_for_type_1: diag(2537, ts.DiagnosticCategory.Error, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."),
                    Type_0_cannot_be_used_as_an_index_type: diag(2538, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."),
                    Cannot_assign_to_0_because_it_is_not_a_variable: diag(2539, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."),
                    Cannot_assign_to_0_because_it_is_a_read_only_property: diag(2540, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."),
                    The_target_of_an_assignment_must_be_a_variable_or_a_property_access: diag(2541, ts.DiagnosticCategory.Error, "The_target_of_an_assignment_must_be_a_variable_or_a_property_access_2541", "The target of an assignment must be a variable or a property access."),
                    Index_signature_in_type_0_only_permits_reading: diag(2542, ts.DiagnosticCategory.Error, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."),
                    Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: diag(2543, ts.DiagnosticCategory.Error, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."),
                    Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: diag(2544, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."),
                    A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: diag(2545, ts.DiagnosticCategory.Error, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."),
                    Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1: diag(2546, ts.DiagnosticCategory.Error, "Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1_2546", "Property '{0}' has conflicting declarations and is inaccessible in type '{1}'."),
                    The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, ts.DiagnosticCategory.Error, "The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value__2547", "The type returned by the 'next()' method of an async iterator must be a promise for a type with a 'value' property."),
                    Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
                    Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
                    Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"),
                    Cannot_find_name_0_Did_you_mean_1: diag(2552, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"),
                    Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, ts.DiagnosticCategory.Error, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."),
                    Expected_0_arguments_but_got_1: diag(2554, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."),
                    Expected_at_least_0_arguments_but_got_1: diag(2555, ts.DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."),
                    Expected_0_arguments_but_got_1_or_more: diag(2556, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_or_more_2556", "Expected {0} arguments, but got {1} or more."),
                    Expected_at_least_0_arguments_but_got_1_or_more: diag(2557, ts.DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_or_more_2557", "Expected at least {0} arguments, but got {1} or more."),
                    Expected_0_type_arguments_but_got_1: diag(2558, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."),
                    Type_0_has_no_properties_in_common_with_type_1: diag(2559, ts.DiagnosticCategory.Error, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."),
                    Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: diag(2560, ts.DiagnosticCategory.Error, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"),
                    Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: diag(2561, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"),
                    Base_class_expressions_cannot_reference_class_type_parameters: diag(2562, ts.DiagnosticCategory.Error, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."),
                    The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: diag(2563, ts.DiagnosticCategory.Error, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."),
                    Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: diag(2564, ts.DiagnosticCategory.Error, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."),
                    Property_0_is_used_before_being_assigned: diag(2565, ts.DiagnosticCategory.Error, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."),
                    A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."),
                    Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts.DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."),
                    Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."),
                    Property_0_does_not_exist_on_type_1_Did_you_forget_to_use_await: diag(2570, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_forget_to_use_await_2570", "Property '{0}' does not exist on type '{1}'. Did you forget to use 'await'?"),
                    Object_is_of_type_unknown: diag(2571, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
                    Rest_signatures_are_incompatible: diag(2572, ts.DiagnosticCategory.Error, "Rest_signatures_are_incompatible_2572", "Rest signatures are incompatible."),
                    Property_0_is_incompatible_with_rest_element_type: diag(2573, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_rest_element_type_2573", "Property '{0}' is incompatible with rest element type."),
                    A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."),
                    No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts.DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."),
                    Property_0_is_a_static_member_of_type_1: diag(2576, ts.DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'"),
                    Return_type_annotation_circularly_references_itself: diag(2577, ts.DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node`."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery: diag(2581, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery`."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha: diag(2582, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha`."),
                    Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2583, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."),
                    Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to include 'dom'."),
                    _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."),
                    Enum_type_0_circularly_references_itself: diag(2586, ts.DiagnosticCategory.Error, "Enum_type_0_circularly_references_itself_2586", "Enum type '{0}' circularly references itself."),
                    JSDoc_type_0_circularly_references_itself: diag(2587, ts.DiagnosticCategory.Error, "JSDoc_type_0_circularly_references_itself_2587", "JSDoc type '{0}' circularly references itself."),
                    Cannot_assign_to_0_because_it_is_a_constant: diag(2588, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."),
                    Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, ts.DiagnosticCategory.Error, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."),
                    Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, ts.DiagnosticCategory.Error, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_th_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node` and then add `node` to the types field in your tsconfig."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_an_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery` and then add `jquery` to the types field in your tsconfig."),
                    Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig."),
                    JSX_element_attributes_type_0_may_not_be_a_union_type: diag(2600, ts.DiagnosticCategory.Error, "JSX_element_attributes_type_0_may_not_be_a_union_type_2600", "JSX element attributes type '{0}' may not be a union type."),
                    The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: diag(2601, ts.DiagnosticCategory.Error, "The_return_type_of_a_JSX_element_constructor_must_return_an_object_type_2601", "The return type of a JSX element constructor must return an object type."),
                    JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: diag(2602, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."),
                    Property_0_in_type_1_is_not_assignable_to_type_2: diag(2603, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."),
                    JSX_element_type_0_does_not_have_any_construct_or_call_signatures: diag(2604, ts.DiagnosticCategory.Error, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."),
                    JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: diag(2605, ts.DiagnosticCategory.Error, "JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements_2605", "JSX element type '{0}' is not a constructor function for JSX elements."),
                    Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: diag(2606, ts.DiagnosticCategory.Error, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."),
                    JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: diag(2607, ts.DiagnosticCategory.Error, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."),
                    The_global_type_JSX_0_may_not_have_more_than_one_property: diag(2608, ts.DiagnosticCategory.Error, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."),
                    JSX_spread_child_must_be_an_array_type: diag(2609, ts.DiagnosticCategory.Error, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."),
                    Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
                    A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
                    Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
                    Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, ts.DiagnosticCategory.Error, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."),
                    Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: diag(2654, ts.DiagnosticCategory.Error, "Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_pack_2654", "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition."),
                    Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: diag(2656, ts.DiagnosticCategory.Error, "Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_2656", "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition."),
                    JSX_expressions_must_have_one_parent_element: diag(2657, ts.DiagnosticCategory.Error, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."),
                    Type_0_provides_no_match_for_the_signature_1: diag(2658, ts.DiagnosticCategory.Error, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."),
                    super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, ts.DiagnosticCategory.Error, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."),
                    super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: diag(2660, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."),
                    Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: diag(2661, ts.DiagnosticCategory.Error, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."),
                    Cannot_find_name_0_Did_you_mean_the_static_member_1_0: diag(2662, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"),
                    Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: diag(2663, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"),
                    Invalid_module_name_in_augmentation_module_0_cannot_be_found: diag(2664, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."),
                    Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: diag(2665, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."),
                    Exports_and_export_assignments_are_not_permitted_in_module_augmentations: diag(2666, ts.DiagnosticCategory.Error, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."),
                    Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: diag(2667, ts.DiagnosticCategory.Error, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."),
                    export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: diag(2668, ts.DiagnosticCategory.Error, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."),
                    Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: diag(2669, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."),
                    Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: diag(2670, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."),
                    Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: diag(2671, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."),
                    Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: diag(2672, ts.DiagnosticCategory.Error, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."),
                    Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: diag(2673, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."),
                    Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: diag(2674, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."),
                    Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: diag(2675, ts.DiagnosticCategory.Error, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."),
                    Accessors_must_both_be_abstract_or_non_abstract: diag(2676, ts.DiagnosticCategory.Error, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."),
                    A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: diag(2677, ts.DiagnosticCategory.Error, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."),
                    Type_0_is_not_comparable_to_type_1: diag(2678, ts.DiagnosticCategory.Error, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."),
                    A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: diag(2679, ts.DiagnosticCategory.Error, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."),
                    A_0_parameter_must_be_the_first_parameter: diag(2680, ts.DiagnosticCategory.Error, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."),
                    A_constructor_cannot_have_a_this_parameter: diag(2681, ts.DiagnosticCategory.Error, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."),
                    get_and_set_accessor_must_have_the_same_this_type: diag(2682, ts.DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_this_type_2682", "'get' and 'set' accessor must have the same 'this' type."),
                    this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: diag(2683, ts.DiagnosticCategory.Error, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."),
                    The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: diag(2684, ts.DiagnosticCategory.Error, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."),
                    The_this_types_of_each_signature_are_incompatible: diag(2685, ts.DiagnosticCategory.Error, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."),
                    _0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: diag(2686, ts.DiagnosticCategory.Error, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."),
                    All_declarations_of_0_must_have_identical_modifiers: diag(2687, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."),
                    Cannot_find_type_definition_file_for_0: diag(2688, ts.DiagnosticCategory.Error, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."),
                    Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, ts.DiagnosticCategory.Error, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"),
                    An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, ts.DiagnosticCategory.Error, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."),
                    _0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, ts.DiagnosticCategory.Error, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."),
                    _0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."),
                    Namespace_0_has_no_exported_member_1: diag(2694, ts.DiagnosticCategory.Error, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."),
                    Left_side_of_comma_operator_is_unused_and_has_no_side_effects: diag(2695, ts.DiagnosticCategory.Error, "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", "Left side of comma operator is unused and has no side effects.", /*reportsUnnecessary*/ true),
                    The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, ts.DiagnosticCategory.Error, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"),
                    An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2697, ts.DiagnosticCategory.Error, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."),
                    Spread_types_may_only_be_created_from_object_types: diag(2698, ts.DiagnosticCategory.Error, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."),
                    Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: diag(2699, ts.DiagnosticCategory.Error, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."),
                    Rest_types_may_only_be_created_from_object_types: diag(2700, ts.DiagnosticCategory.Error, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."),
                    The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: diag(2701, ts.DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."),
                    _0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: diag(2702, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."),
                    The_operand_of_a_delete_operator_must_be_a_property_reference: diag(2703, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a delete operator must be a property reference."),
                    The_operand_of_a_delete_operator_cannot_be_a_read_only_property: diag(2704, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a delete operator cannot be a read-only property."),
                    An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2705, ts.DiagnosticCategory.Error, "An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_de_2705", "An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."),
                    Required_type_parameters_may_not_follow_optional_type_parameters: diag(2706, ts.DiagnosticCategory.Error, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."),
                    Generic_type_0_requires_between_1_and_2_type_arguments: diag(2707, ts.DiagnosticCategory.Error, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."),
                    Cannot_use_namespace_0_as_a_value: diag(2708, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."),
                    Cannot_use_namespace_0_as_a_type: diag(2709, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."),
                    _0_are_specified_twice_The_attribute_named_0_will_be_overwritten: diag(2710, ts.DiagnosticCategory.Error, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."),
                    A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2711, ts.DiagnosticCategory.Error, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."),
                    A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2712, ts.DiagnosticCategory.Error, "A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declarat_2712", "A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."),
                    Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: diag(2713, ts.DiagnosticCategory.Error, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", "Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}[\"{1}\"]'?"),
                    The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: diag(2714, ts.DiagnosticCategory.Error, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."),
                    Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: diag(2715, ts.DiagnosticCategory.Error, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."),
                    Type_parameter_0_has_a_circular_default: diag(2716, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."),
                    Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: diag(2717, ts.DiagnosticCategory.Error, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type.  Property '{0}' must be of type '{1}', but here has type '{2}'."),
                    Duplicate_property_0: diag(2718, ts.DiagnosticCategory.Error, "Duplicate_property_0_2718", "Duplicate property '{0}'."),
                    Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: diag(2719, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."),
                    Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: diag(2720, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"),
                    Cannot_invoke_an_object_which_is_possibly_null: diag(2721, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."),
                    Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."),
                    Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."),
                    Module_0_has_no_exported_member_1_Did_you_mean_2: diag(2724, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_2_2724", "Module '{0}' has no exported member '{1}'. Did you mean '{2}'?"),
                    Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, ts.DiagnosticCategory.Error, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."),
                    Cannot_find_lib_definition_for_0: diag(2726, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."),
                    Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"),
                    _0_is_declared_here: diag(2728, ts.DiagnosticCategory.Message, "_0_is_declared_here_2728", "'{0}' is declared here."),
                    Property_0_is_used_before_its_initialization: diag(2729, ts.DiagnosticCategory.Error, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."),
                    An_arrow_function_cannot_have_a_this_parameter: diag(2730, ts.DiagnosticCategory.Error, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."),
                    Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, ts.DiagnosticCategory.Error, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."),
                    Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension"),
                    Property_0_was_also_declared_here: diag(2733, ts.DiagnosticCategory.Error, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."),
                    It_is_highly_likely_that_you_are_missing_a_semicolon: diag(2734, ts.DiagnosticCategory.Error, "It_is_highly_likely_that_you_are_missing_a_semicolon_2734", "It is highly likely that you are missing a semicolon."),
                    Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, ts.DiagnosticCategory.Error, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"),
                    Operator_0_cannot_be_applied_to_type_1: diag(2736, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."),
                    BigInt_literals_are_not_available_when_targeting_lower_than_ESNext: diag(2737, ts.DiagnosticCategory.Error, "BigInt_literals_are_not_available_when_targeting_lower_than_ESNext_2737", "BigInt literals are not available when targeting lower than ESNext."),
                    An_outer_value_of_this_is_shadowed_by_this_container: diag(2738, ts.DiagnosticCategory.Message, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."),
                    Type_0_is_missing_the_following_properties_from_type_1_Colon_2: diag(2739, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"),
                    Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: diag(2740, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."),
                    Property_0_is_missing_in_type_1_but_required_in_type_2: diag(2741, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."),
                    The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2742, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."),
                    No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: diag(2743, ts.DiagnosticCategory.Error, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."),
                    Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: diag(2744, ts.DiagnosticCategory.Error, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."),
                    This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: diag(2745, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."),
                    This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: diag(2746, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."),
                    _0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: diag(2747, ts.DiagnosticCategory.Error, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."),
                    Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided: diag(2748, ts.DiagnosticCategory.Error, "Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided_2748", "Cannot access ambient const enums when the '--isolatedModules' flag is provided."),
                    _0_refers_to_a_value_but_is_being_used_as_a_type_here: diag(2749, ts.DiagnosticCategory.Error, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_2749", "'{0}' refers to a value, but is being used as a type here."),
                    The_implementation_signature_is_declared_here: diag(2750, ts.DiagnosticCategory.Error, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."),
                    Circularity_originates_in_type_at_this_location: diag(2751, ts.DiagnosticCategory.Error, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."),
                    The_first_export_default_is_here: diag(2752, ts.DiagnosticCategory.Error, "The_first_export_default_is_here_2752", "The first export default is here."),
                    Another_export_default_is_here: diag(2753, ts.DiagnosticCategory.Error, "Another_export_default_is_here_2753", "Another export default is here."),
                    Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
                    Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
                    Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
                    Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4006, ts.DiagnosticCategory.Error, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."),
                    Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4008, ts.DiagnosticCategory.Error, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."),
                    Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4010, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."),
                    Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4012, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."),
                    Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4014, ts.DiagnosticCategory.Error, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."),
                    Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."),
                    Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, ts.DiagnosticCategory.Error, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."),
                    extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."),
                    extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, ts.DiagnosticCategory.Error, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."),
                    Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."),
                    Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."),
                    Exported_variable_0_has_or_is_using_private_name_1: diag(4025, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."),
                    Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4026, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4027, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
                    Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4028, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."),
                    Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4029, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4030, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
                    Public_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4031, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."),
                    Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4032, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."),
                    Property_0_of_exported_interface_has_or_is_using_private_name_1: diag(4033, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."),
                    Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4034, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
                    Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4035, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."),
                    Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4036, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
                    Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4037, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."),
                    Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4038, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4039, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
                    Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4040, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."),
                    Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4041, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4042, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
                    Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4043, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."),
                    Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4044, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4045, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."),
                    Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4046, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4047, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."),
                    Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4048, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4049, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."),
                    Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4050, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."),
                    Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4051, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: diag(4052, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."),
                    Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4053, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."),
                    Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4054, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: diag(4055, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."),
                    Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4056, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: diag(4057, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."),
                    Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4058, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."),
                    Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: diag(4059, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."),
                    Return_type_of_exported_function_has_or_is_using_private_name_0: diag(4060, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."),
                    Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4061, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4062, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: diag(4063, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."),
                    Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4064, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4065, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."),
                    Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4066, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4067, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."),
                    Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4068, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4069, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4070, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."),
                    Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4071, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4072, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4073, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."),
                    Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4074, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4075, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."),
                    Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4076, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."),
                    Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: diag(4077, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4078, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."),
                    Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."),
                    Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, ts.DiagnosticCategory.Error, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."),
                    Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."),
                    Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, ts.DiagnosticCategory.Error, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."),
                    Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."),
                    Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."),
                    Property_0_of_exported_class_expression_may_not_be_private_or_protected: diag(4094, ts.DiagnosticCategory.Error, "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094", "Property '{0}' of exported class expression may not be private or protected."),
                    Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4095, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4096, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
                    Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4097, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."),
                    Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4098, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
                    Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4099, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
                    Public_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4100, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."),
                    Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4101, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."),
                    Method_0_of_exported_interface_has_or_is_using_private_name_1: diag(4102, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."),
                    Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: diag(4103, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."),
                    The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."),
                    Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."),
                    File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."),
                    Cannot_read_file_0_Colon_1: diag(5012, ts.DiagnosticCategory.Error, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."),
                    Failed_to_parse_file_0_Colon_1: diag(5014, ts.DiagnosticCategory.Error, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."),
                    Unknown_compiler_option_0: diag(5023, ts.DiagnosticCategory.Error, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."),
                    Compiler_option_0_requires_a_value_of_type_1: diag(5024, ts.DiagnosticCategory.Error, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."),
                    Could_not_write_file_0_Colon_1: diag(5033, ts.DiagnosticCategory.Error, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."),
                    Option_project_cannot_be_mixed_with_source_files_on_a_command_line: diag(5042, ts.DiagnosticCategory.Error, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."),
                    Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: diag(5047, ts.DiagnosticCategory.Error, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."),
                    Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: diag(5051, ts.DiagnosticCategory.Error, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."),
                    Option_0_cannot_be_specified_without_specifying_option_1: diag(5052, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."),
                    Option_0_cannot_be_specified_with_option_1: diag(5053, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."),
                    A_tsconfig_json_file_is_already_defined_at_Colon_0: diag(5054, ts.DiagnosticCategory.Error, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."),
                    Cannot_write_file_0_because_it_would_overwrite_input_file: diag(5055, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."),
                    Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: diag(5056, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."),
                    Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."),
                    The_specified_path_does_not_exist_Colon_0: diag(5058, ts.DiagnosticCategory.Error, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."),
                    Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, ts.DiagnosticCategory.Error, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."),
                    Option_paths_cannot_be_used_without_specifying_baseUrl_option: diag(5060, ts.DiagnosticCategory.Error, "Option_paths_cannot_be_used_without_specifying_baseUrl_option_5060", "Option 'paths' cannot be used without specifying '--baseUrl' option."),
                    Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, ts.DiagnosticCategory.Error, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."),
                    Substitution_0_in_pattern_1_in_can_have_at_most_one_Asterisk_character: diag(5062, ts.DiagnosticCategory.Error, "Substitution_0_in_pattern_1_in_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' in can have at most one '*' character."),
                    Substitutions_for_pattern_0_should_be_an_array: diag(5063, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."),
                    Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: diag(5064, ts.DiagnosticCategory.Error, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."),
                    File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5065, ts.DiagnosticCategory.Error, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."),
                    Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: diag(5066, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."),
                    Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(5067, ts.DiagnosticCategory.Error, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."),
                    Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: diag(5068, ts.DiagnosticCategory.Error, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."),
                    Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: diag(5069, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."),
                    Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy: diag(5070, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy_5070", "Option '--resolveJsonModule' cannot be specified without 'node' module resolution strategy."),
                    Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext: diag(5071, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_5071", "Option '--resolveJsonModule' can only be specified when module code generation is 'commonjs', 'amd', 'es2015' or 'esNext'."),
                    Unknown_build_option_0: diag(5072, ts.DiagnosticCategory.Error, "Unknown_build_option_0_5072", "Unknown build option '{0}'."),
                    Build_option_0_requires_a_value_of_type_1: diag(5073, ts.DiagnosticCategory.Error, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."),
                    Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts.DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."),
                    Concatenate_and_emit_output_to_single_file: diag(6001, ts.DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."),
                    Generates_corresponding_d_ts_file: diag(6002, ts.DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."),
                    Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: diag(6003, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6003", "Specify the location where debugger should locate map files instead of generated locations."),
                    Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: diag(6004, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."),
                    Watch_input_files: diag(6005, ts.DiagnosticCategory.Message, "Watch_input_files_6005", "Watch input files."),
                    Redirect_output_structure_to_the_directory: diag(6006, ts.DiagnosticCategory.Message, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."),
                    Do_not_erase_const_enum_declarations_in_generated_code: diag(6007, ts.DiagnosticCategory.Message, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."),
                    Do_not_emit_outputs_if_any_errors_were_reported: diag(6008, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."),
                    Do_not_emit_comments_to_output: diag(6009, ts.DiagnosticCategory.Message, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."),
                    Do_not_emit_outputs: diag(6010, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_6010", "Do not emit outputs."),
                    Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: diag(6011, ts.DiagnosticCategory.Message, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."),
                    Skip_type_checking_of_declaration_files: diag(6012, ts.DiagnosticCategory.Message, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."),
                    Do_not_resolve_the_real_path_of_symlinks: diag(6013, ts.DiagnosticCategory.Message, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."),
                    Only_emit_d_ts_declaration_files: diag(6014, ts.DiagnosticCategory.Message, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."),
                    Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_or_ESNEXT: diag(6015, ts.DiagnosticCategory.Message, "Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_or_ESNEXT_6015", "Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'."),
                    Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_or_ESNext: diag(6016, ts.DiagnosticCategory.Message, "Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_or_ESNext_6016", "Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'."),
                    Print_this_message: diag(6017, ts.DiagnosticCategory.Message, "Print_this_message_6017", "Print this message."),
                    Print_the_compiler_s_version: diag(6019, ts.DiagnosticCategory.Message, "Print_the_compiler_s_version_6019", "Print the compiler's version."),
                    Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: diag(6020, ts.DiagnosticCategory.Message, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."),
                    Syntax_Colon_0: diag(6023, ts.DiagnosticCategory.Message, "Syntax_Colon_0_6023", "Syntax: {0}"),
                    options: diag(6024, ts.DiagnosticCategory.Message, "options_6024", "options"),
                    file: diag(6025, ts.DiagnosticCategory.Message, "file_6025", "file"),
                    Examples_Colon_0: diag(6026, ts.DiagnosticCategory.Message, "Examples_Colon_0_6026", "Examples: {0}"),
                    Options_Colon: diag(6027, ts.DiagnosticCategory.Message, "Options_Colon_6027", "Options:"),
                    Version_0: diag(6029, ts.DiagnosticCategory.Message, "Version_0_6029", "Version {0}"),
                    Insert_command_line_options_and_files_from_a_file: diag(6030, ts.DiagnosticCategory.Message, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."),
                    Starting_compilation_in_watch_mode: diag(6031, ts.DiagnosticCategory.Message, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."),
                    File_change_detected_Starting_incremental_compilation: diag(6032, ts.DiagnosticCategory.Message, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."),
                    KIND: diag(6034, ts.DiagnosticCategory.Message, "KIND_6034", "KIND"),
                    FILE: diag(6035, ts.DiagnosticCategory.Message, "FILE_6035", "FILE"),
                    VERSION: diag(6036, ts.DiagnosticCategory.Message, "VERSION_6036", "VERSION"),
                    LOCATION: diag(6037, ts.DiagnosticCategory.Message, "LOCATION_6037", "LOCATION"),
                    DIRECTORY: diag(6038, ts.DiagnosticCategory.Message, "DIRECTORY_6038", "DIRECTORY"),
                    STRATEGY: diag(6039, ts.DiagnosticCategory.Message, "STRATEGY_6039", "STRATEGY"),
                    FILE_OR_DIRECTORY: diag(6040, ts.DiagnosticCategory.Message, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"),
                    Generates_corresponding_map_file: diag(6043, ts.DiagnosticCategory.Message, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."),
                    Compiler_option_0_expects_an_argument: diag(6044, ts.DiagnosticCategory.Error, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."),
                    Unterminated_quoted_string_in_response_file_0: diag(6045, ts.DiagnosticCategory.Error, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."),
                    Argument_for_0_option_must_be_Colon_1: diag(6046, ts.DiagnosticCategory.Error, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."),
                    Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: diag(6048, ts.DiagnosticCategory.Error, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'."),
                    Unsupported_locale_0: diag(6049, ts.DiagnosticCategory.Error, "Unsupported_locale_0_6049", "Unsupported locale '{0}'."),
                    Unable_to_open_file_0: diag(6050, ts.DiagnosticCategory.Error, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."),
                    Corrupted_locale_file_0: diag(6051, ts.DiagnosticCategory.Error, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."),
                    Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, ts.DiagnosticCategory.Message, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."),
                    File_0_not_found: diag(6053, ts.DiagnosticCategory.Error, "File_0_not_found_6053", "File '{0}' not found."),
                    File_0_has_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, ts.DiagnosticCategory.Error, "File_0_has_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has unsupported extension. The only supported extensions are {1}."),
                    Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: diag(6055, ts.DiagnosticCategory.Message, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."),
                    Do_not_emit_declarations_for_code_that_has_an_internal_annotation: diag(6056, ts.DiagnosticCategory.Message, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."),
                    Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: diag(6058, ts.DiagnosticCategory.Message, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."),
                    File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: diag(6059, ts.DiagnosticCategory.Error, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."),
                    Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: diag(6060, ts.DiagnosticCategory.Message, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."),
                    NEWLINE: diag(6061, ts.DiagnosticCategory.Message, "NEWLINE_6061", "NEWLINE"),
                    Option_0_can_only_be_specified_in_tsconfig_json_file: diag(6064, ts.DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_6064", "Option '{0}' can only be specified in 'tsconfig.json' file."),
                    Enables_experimental_support_for_ES7_decorators: diag(6065, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."),
                    Enables_experimental_support_for_emitting_type_metadata_for_decorators: diag(6066, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."),
                    Enables_experimental_support_for_ES7_async_functions: diag(6068, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_async_functions_6068", "Enables experimental support for ES7 async functions."),
                    Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: diag(6069, ts.DiagnosticCategory.Message, "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)."),
                    Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: diag(6070, ts.DiagnosticCategory.Message, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."),
                    Successfully_created_a_tsconfig_json_file: diag(6071, ts.DiagnosticCategory.Message, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."),
                    Suppress_excess_property_checks_for_object_literals: diag(6072, ts.DiagnosticCategory.Message, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."),
                    Stylize_errors_and_messages_using_color_and_context_experimental: diag(6073, ts.DiagnosticCategory.Message, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."),
                    Do_not_report_errors_on_unused_labels: diag(6074, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."),
                    Report_error_when_not_all_code_paths_in_function_return_a_value: diag(6075, ts.DiagnosticCategory.Message, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."),
                    Report_errors_for_fallthrough_cases_in_switch_statement: diag(6076, ts.DiagnosticCategory.Message, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."),
                    Do_not_report_errors_on_unreachable_code: diag(6077, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."),
                    Disallow_inconsistently_cased_references_to_the_same_file: diag(6078, ts.DiagnosticCategory.Message, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."),
                    Specify_library_files_to_be_included_in_the_compilation: diag(6079, ts.DiagnosticCategory.Message, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."),
                    Specify_JSX_code_generation_Colon_preserve_react_native_or_react: diag(6080, ts.DiagnosticCategory.Message, "Specify_JSX_code_generation_Colon_preserve_react_native_or_react_6080", "Specify JSX code generation: 'preserve', 'react-native', or 'react'."),
                    File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, ts.DiagnosticCategory.Message, "File_0_has_an_unsupported_extension_so_skipping_it_6081", "File '{0}' has an unsupported extension, so skipping it."),
                    Only_amd_and_system_modules_are_supported_alongside_0: diag(6082, ts.DiagnosticCategory.Error, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."),
                    Base_directory_to_resolve_non_absolute_module_names: diag(6083, ts.DiagnosticCategory.Message, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."),
                    Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: diag(6084, ts.DiagnosticCategory.Message, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"),
                    Enable_tracing_of_the_name_resolution_process: diag(6085, ts.DiagnosticCategory.Message, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."),
                    Resolving_module_0_from_1: diag(6086, ts.DiagnosticCategory.Message, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"),
                    Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, ts.DiagnosticCategory.Message, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."),
                    Module_resolution_kind_is_not_specified_using_0: diag(6088, ts.DiagnosticCategory.Message, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."),
                    Module_name_0_was_successfully_resolved_to_1: diag(6089, ts.DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"),
                    Module_name_0_was_not_resolved: diag(6090, ts.DiagnosticCategory.Message, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"),
                    paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: diag(6091, ts.DiagnosticCategory.Message, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."),
                    Module_name_0_matched_pattern_1: diag(6092, ts.DiagnosticCategory.Message, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."),
                    Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, ts.DiagnosticCategory.Message, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."),
                    Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, ts.DiagnosticCategory.Message, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."),
                    Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1: diag(6095, ts.DiagnosticCategory.Message, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1_6095", "Loading module as file / folder, candidate module location '{0}', target file type '{1}'."),
                    File_0_does_not_exist: diag(6096, ts.DiagnosticCategory.Message, "File_0_does_not_exist_6096", "File '{0}' does not exist."),
                    File_0_exist_use_it_as_a_name_resolution_result: diag(6097, ts.DiagnosticCategory.Message, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."),
                    Loading_module_0_from_node_modules_folder_target_file_type_1: diag(6098, ts.DiagnosticCategory.Message, "Loading_module_0_from_node_modules_folder_target_file_type_1_6098", "Loading module '{0}' from 'node_modules' folder, target file type '{1}'."),
                    Found_package_json_at_0: diag(6099, ts.DiagnosticCategory.Message, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."),
                    package_json_does_not_have_a_0_field: diag(6100, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."),
                    package_json_has_0_field_1_that_references_2: diag(6101, ts.DiagnosticCategory.Message, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."),
                    Allow_javascript_files_to_be_compiled: diag(6102, ts.DiagnosticCategory.Message, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."),
                    Option_0_should_have_array_of_strings_as_a_value: diag(6103, ts.DiagnosticCategory.Error, "Option_0_should_have_array_of_strings_as_a_value_6103", "Option '{0}' should have array of strings as a value."),
                    Checking_if_0_is_the_longest_matching_prefix_for_1_2: diag(6104, ts.DiagnosticCategory.Message, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."),
                    Expected_type_of_0_field_in_package_json_to_be_1_got_2: diag(6105, ts.DiagnosticCategory.Message, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."),
                    baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: diag(6106, ts.DiagnosticCategory.Message, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."),
                    rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: diag(6107, ts.DiagnosticCategory.Message, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."),
                    Longest_matching_prefix_for_0_is_1: diag(6108, ts.DiagnosticCategory.Message, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."),
                    Loading_0_from_the_root_dir_1_candidate_location_2: diag(6109, ts.DiagnosticCategory.Message, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."),
                    Trying_other_entries_in_rootDirs: diag(6110, ts.DiagnosticCategory.Message, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."),
                    Module_resolution_using_rootDirs_has_failed: diag(6111, ts.DiagnosticCategory.Message, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."),
                    Do_not_emit_use_strict_directives_in_module_output: diag(6112, ts.DiagnosticCategory.Message, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."),
                    Enable_strict_null_checks: diag(6113, ts.DiagnosticCategory.Message, "Enable_strict_null_checks_6113", "Enable strict null checks."),
                    Unknown_option_excludes_Did_you_mean_exclude: diag(6114, ts.DiagnosticCategory.Error, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"),
                    Raise_error_on_this_expressions_with_an_implied_any_type: diag(6115, ts.DiagnosticCategory.Message, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."),
                    Resolving_type_reference_directive_0_containing_file_1_root_directory_2: diag(6116, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"),
                    Resolving_using_primary_search_paths: diag(6117, ts.DiagnosticCategory.Message, "Resolving_using_primary_search_paths_6117", "Resolving using primary search paths..."),
                    Resolving_from_node_modules_folder: diag(6118, ts.DiagnosticCategory.Message, "Resolving_from_node_modules_folder_6118", "Resolving from node_modules folder..."),
                    Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: diag(6119, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"),
                    Type_reference_directive_0_was_not_resolved: diag(6120, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"),
                    Resolving_with_primary_search_path_0: diag(6121, ts.DiagnosticCategory.Message, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."),
                    Root_directory_cannot_be_determined_skipping_primary_search_paths: diag(6122, ts.DiagnosticCategory.Message, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."),
                    Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: diag(6123, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"),
                    Type_declaration_files_to_be_included_in_compilation: diag(6124, ts.DiagnosticCategory.Message, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."),
                    Looking_up_in_node_modules_folder_initial_location_0: diag(6125, ts.DiagnosticCategory.Message, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."),
                    Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: diag(6126, ts.DiagnosticCategory.Message, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."),
                    Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: diag(6127, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"),
                    Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: diag(6128, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"),
                    Resolving_real_path_for_0_result_1: diag(6130, ts.DiagnosticCategory.Message, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."),
                    Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: diag(6131, ts.DiagnosticCategory.Error, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."),
                    File_name_0_has_a_1_extension_stripping_it: diag(6132, ts.DiagnosticCategory.Message, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."),
                    _0_is_declared_but_its_value_is_never_read: diag(6133, ts.DiagnosticCategory.Error, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", /*reportsUnnecessary*/ true),
                    Report_errors_on_unused_locals: diag(6134, ts.DiagnosticCategory.Message, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."),
                    Report_errors_on_unused_parameters: diag(6135, ts.DiagnosticCategory.Message, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."),
                    The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: diag(6136, ts.DiagnosticCategory.Message, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."),
                    Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: diag(6137, ts.DiagnosticCategory.Error, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."),
                    Property_0_is_declared_but_its_value_is_never_read: diag(6138, ts.DiagnosticCategory.Error, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", /*reportsUnnecessary*/ true),
                    Import_emit_helpers_from_tslib: diag(6139, ts.DiagnosticCategory.Message, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."),
                    Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: diag(6140, ts.DiagnosticCategory.Error, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."),
                    Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: diag(6141, ts.DiagnosticCategory.Message, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", "Parse in strict mode and emit \"use strict\" for each source file."),
                    Module_0_was_resolved_to_1_but_jsx_is_not_set: diag(6142, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."),
                    Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: diag(6144, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."),
                    Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified: diag(6145, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified_6145", "Module '{0}' was resolved as ambient module declared in '{1}' since this file was not modified."),
                    Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: diag(6146, ts.DiagnosticCategory.Message, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."),
                    Resolution_for_module_0_was_found_in_cache_from_location_1: diag(6147, ts.DiagnosticCategory.Message, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."),
                    Directory_0_does_not_exist_skipping_all_lookups_in_it: diag(6148, ts.DiagnosticCategory.Message, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."),
                    Show_diagnostic_information: diag(6149, ts.DiagnosticCategory.Message, "Show_diagnostic_information_6149", "Show diagnostic information."),
                    Show_verbose_diagnostic_information: diag(6150, ts.DiagnosticCategory.Message, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."),
                    Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: diag(6151, ts.DiagnosticCategory.Message, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."),
                    Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: diag(6152, ts.DiagnosticCategory.Message, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."),
                    Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: diag(6153, ts.DiagnosticCategory.Message, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts.transpileModule')."),
                    Print_names_of_generated_files_part_of_the_compilation: diag(6154, ts.DiagnosticCategory.Message, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."),
                    Print_names_of_files_part_of_the_compilation: diag(6155, ts.DiagnosticCategory.Message, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."),
                    The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: diag(6156, ts.DiagnosticCategory.Message, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"),
                    Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: diag(6157, ts.DiagnosticCategory.Message, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."),
                    Do_not_include_the_default_library_file_lib_d_ts: diag(6158, ts.DiagnosticCategory.Message, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."),
                    Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: diag(6159, ts.DiagnosticCategory.Message, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."),
                    Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: diag(6160, ts.DiagnosticCategory.Message, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."),
                    List_of_folders_to_include_type_definitions_from: diag(6161, ts.DiagnosticCategory.Message, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."),
                    Disable_size_limitations_on_JavaScript_projects: diag(6162, ts.DiagnosticCategory.Message, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."),
                    The_character_set_of_the_input_files: diag(6163, ts.DiagnosticCategory.Message, "The_character_set_of_the_input_files_6163", "The character set of the input files."),
                    Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: diag(6164, ts.DiagnosticCategory.Message, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6164", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."),
                    Do_not_truncate_error_messages: diag(6165, ts.DiagnosticCategory.Message, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."),
                    Output_directory_for_generated_declaration_files: diag(6166, ts.DiagnosticCategory.Message, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."),
                    A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: diag(6167, ts.DiagnosticCategory.Message, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."),
                    List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: diag(6168, ts.DiagnosticCategory.Message, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."),
                    Show_all_compiler_options: diag(6169, ts.DiagnosticCategory.Message, "Show_all_compiler_options_6169", "Show all compiler options."),
                    Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, ts.DiagnosticCategory.Message, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"),
                    Command_line_Options: diag(6171, ts.DiagnosticCategory.Message, "Command_line_Options_6171", "Command-line Options"),
                    Basic_Options: diag(6172, ts.DiagnosticCategory.Message, "Basic_Options_6172", "Basic Options"),
                    Strict_Type_Checking_Options: diag(6173, ts.DiagnosticCategory.Message, "Strict_Type_Checking_Options_6173", "Strict Type-Checking Options"),
                    Module_Resolution_Options: diag(6174, ts.DiagnosticCategory.Message, "Module_Resolution_Options_6174", "Module Resolution Options"),
                    Source_Map_Options: diag(6175, ts.DiagnosticCategory.Message, "Source_Map_Options_6175", "Source Map Options"),
                    Additional_Checks: diag(6176, ts.DiagnosticCategory.Message, "Additional_Checks_6176", "Additional Checks"),
                    Experimental_Options: diag(6177, ts.DiagnosticCategory.Message, "Experimental_Options_6177", "Experimental Options"),
                    Advanced_Options: diag(6178, ts.DiagnosticCategory.Message, "Advanced_Options_6178", "Advanced Options"),
                    Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3: diag(6179, ts.DiagnosticCategory.Message, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'."),
                    Enable_all_strict_type_checking_options: diag(6180, ts.DiagnosticCategory.Message, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."),
                    List_of_language_service_plugins: diag(6181, ts.DiagnosticCategory.Message, "List_of_language_service_plugins_6181", "List of language service plugins."),
                    Scoped_package_detected_looking_in_0: diag(6182, ts.DiagnosticCategory.Message, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"),
                    Reusing_resolution_of_module_0_to_file_1_from_old_program: diag(6183, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_to_file_1_from_old_program_6183", "Reusing resolution of module '{0}' to file '{1}' from old program."),
                    Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program: diag(6184, ts.DiagnosticCategory.Message, "Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program_6184", "Reusing module resolutions originating in '{0}' since resolutions are unchanged from old program."),
                    Disable_strict_checking_of_generic_signatures_in_function_types: diag(6185, ts.DiagnosticCategory.Message, "Disable_strict_checking_of_generic_signatures_in_function_types_6185", "Disable strict checking of generic signatures in function types."),
                    Enable_strict_checking_of_function_types: diag(6186, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."),
                    Enable_strict_checking_of_property_initialization_in_classes: diag(6187, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."),
                    Numeric_separators_are_not_allowed_here: diag(6188, ts.DiagnosticCategory.Error, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."),
                    Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, ts.DiagnosticCategory.Error, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."),
                    Found_package_json_at_0_Package_ID_is_1: diag(6190, ts.DiagnosticCategory.Message, "Found_package_json_at_0_Package_ID_is_1_6190", "Found 'package.json' at '{0}'. Package ID is '{1}'."),
                    Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: diag(6191, ts.DiagnosticCategory.Message, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."),
                    All_imports_in_import_declaration_are_unused: diag(6192, ts.DiagnosticCategory.Error, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", /*reportsUnnecessary*/ true),
                    Found_1_error_Watching_for_file_changes: diag(6193, ts.DiagnosticCategory.Message, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."),
                    Found_0_errors_Watching_for_file_changes: diag(6194, ts.DiagnosticCategory.Message, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."),
                    Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: diag(6195, ts.DiagnosticCategory.Message, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."),
                    _0_is_declared_but_never_used: diag(6196, ts.DiagnosticCategory.Error, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", /*reportsUnnecessary*/ true),
                    Include_modules_imported_with_json_extension: diag(6197, ts.DiagnosticCategory.Message, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"),
                    All_destructured_elements_are_unused: diag(6198, ts.DiagnosticCategory.Error, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", /*reportsUnnecessary*/ true),
                    All_variables_are_unused: diag(6199, ts.DiagnosticCategory.Error, "All_variables_are_unused_6199", "All variables are unused.", /*reportsUnnecessary*/ true),
                    Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, ts.DiagnosticCategory.Error, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"),
                    Conflicts_are_in_this_file: diag(6201, ts.DiagnosticCategory.Message, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."),
                    _0_was_also_declared_here: diag(6203, ts.DiagnosticCategory.Message, "_0_was_also_declared_here_6203", "'{0}' was also declared here."),
                    and_here: diag(6204, ts.DiagnosticCategory.Message, "and_here_6204", "and here."),
                    All_type_parameters_are_unused: diag(6205, ts.DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused"),
                    package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."),
                    package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."),
                    package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."),
                    package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: diag(6209, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."),
                    An_argument_for_0_was_not_provided: diag(6210, ts.DiagnosticCategory.Message, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."),
                    An_argument_matching_this_binding_pattern_was_not_provided: diag(6211, ts.DiagnosticCategory.Message, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."),
                    Did_you_mean_to_call_this_expression: diag(6212, ts.DiagnosticCategory.Message, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"),
                    Did_you_mean_to_use_new_with_this_expression: diag(6213, ts.DiagnosticCategory.Message, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"),
                    Enable_strict_bind_call_and_apply_methods_on_functions: diag(6214, ts.DiagnosticCategory.Message, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."),
                    Using_compiler_options_of_project_reference_redirect_0: diag(6215, ts.DiagnosticCategory.Message, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."),
                    Found_1_error: diag(6216, ts.DiagnosticCategory.Message, "Found_1_error_6216", "Found 1 error."),
                    Found_0_errors: diag(6217, ts.DiagnosticCategory.Message, "Found_0_errors_6217", "Found {0} errors."),
                    Projects_to_reference: diag(6300, ts.DiagnosticCategory.Message, "Projects_to_reference_6300", "Projects to reference"),
                    Enable_project_compilation: diag(6302, ts.DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"),
                    Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, ts.DiagnosticCategory.Error, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"),
                    Composite_projects_may_not_disable_declaration_emit: diag(6304, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."),
                    Output_file_0_has_not_been_built_from_source_file_1: diag(6305, ts.DiagnosticCategory.Error, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."),
                    Referenced_project_0_must_have_setting_composite_Colon_true: diag(6306, ts.DiagnosticCategory.Error, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", "Referenced project '{0}' must have setting \"composite\": true."),
                    File_0_is_not_in_project_file_list_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, ts.DiagnosticCategory.Error, "File_0_is_not_in_project_file_list_Projects_must_list_all_files_or_use_an_include_pattern_6307", "File '{0}' is not in project file list. Projects must list all files or use an 'include' pattern."),
                    Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"),
                    Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"),
                    Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"),
                    Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"),
                    Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"),
                    Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"),
                    Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"),
                    Projects_in_this_build_Colon_0: diag(6355, ts.DiagnosticCategory.Message, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"),
                    A_non_dry_build_would_delete_the_following_files_Colon_0: diag(6356, ts.DiagnosticCategory.Message, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"),
                    A_non_dry_build_would_build_project_0: diag(6357, ts.DiagnosticCategory.Message, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"),
                    Building_project_0: diag(6358, ts.DiagnosticCategory.Message, "Building_project_0_6358", "Building project '{0}'..."),
                    Updating_output_timestamps_of_project_0: diag(6359, ts.DiagnosticCategory.Message, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."),
                    delete_this_Project_0_is_up_to_date_because_it_was_previously_built: diag(6360, ts.DiagnosticCategory.Message, "delete_this_Project_0_is_up_to_date_because_it_was_previously_built_6360", "delete this - Project '{0}' is up to date because it was previously built"),
                    Project_0_is_up_to_date: diag(6361, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"),
                    Skipping_build_of_project_0_because_its_dependency_1_has_errors: diag(6362, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"),
                    Project_0_can_t_be_built_because_its_dependency_1_has_errors: diag(6363, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"),
                    Build_one_or_more_projects_and_their_dependencies_if_out_of_date: diag(6364, ts.DiagnosticCategory.Message, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"),
                    Delete_the_outputs_of_all_projects: diag(6365, ts.DiagnosticCategory.Message, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects"),
                    Enable_verbose_logging: diag(6366, ts.DiagnosticCategory.Message, "Enable_verbose_logging_6366", "Enable verbose logging"),
                    Show_what_would_be_built_or_deleted_if_specified_with_clean: diag(6367, ts.DiagnosticCategory.Message, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"),
                    Build_all_projects_including_those_that_appear_to_be_up_to_date: diag(6368, ts.DiagnosticCategory.Message, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6368", "Build all projects, including those that appear to be up to date"),
                    Option_build_must_be_the_first_command_line_argument: diag(6369, ts.DiagnosticCategory.Error, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."),
                    Options_0_and_1_cannot_be_combined: diag(6370, ts.DiagnosticCategory.Error, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."),
                    Updating_unchanged_output_timestamps_of_project_0: diag(6371, ts.DiagnosticCategory.Message, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."),
                    Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed: diag(6372, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed_6372", "Project '{0}' is out of date because output of its dependency '{1}' has changed"),
                    Updating_output_of_project_0: diag(6373, ts.DiagnosticCategory.Message, "Updating_output_of_project_0_6373", "Updating output of project '{0}'..."),
                    A_non_dry_build_would_update_timestamps_for_output_of_project_0: diag(6374, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"),
                    A_non_dry_build_would_update_output_of_project_0: diag(6375, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_output_of_project_0_6375", "A non-dry build would update output of project '{0}'"),
                    Cannot_update_output_of_project_0_because_there_was_error_reading_file_1: diag(6376, ts.DiagnosticCategory.Message, "Cannot_update_output_of_project_0_because_there_was_error_reading_file_1_6376", "Cannot update output of project '{0}' because there was error reading file '{1}'"),
                    Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: diag(6377, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"),
                    Enable_incremental_compilation: diag(6378, ts.DiagnosticCategory.Message, "Enable_incremental_compilation_6378", "Enable incremental compilation"),
                    Composite_projects_may_not_disable_incremental_compilation: diag(6379, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."),
                    Specify_file_to_store_incremental_compilation_information: diag(6380, ts.DiagnosticCategory.Message, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"),
                    Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: diag(6381, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"),
                    The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
                    The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
                    The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
                    Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."),
                    Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."),
                    Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."),
                    new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: diag(7009, ts.DiagnosticCategory.Error, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."),
                    _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: diag(7010, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."),
                    Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7011, ts.DiagnosticCategory.Error, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."),
                    Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7013, ts.DiagnosticCategory.Error, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."),
                    Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7014, ts.DiagnosticCategory.Error, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."),
                    Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: diag(7015, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."),
                    Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: diag(7016, ts.DiagnosticCategory.Error, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."),
                    Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: diag(7017, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."),
                    Object_literal_s_property_0_implicitly_has_an_1_type: diag(7018, ts.DiagnosticCategory.Error, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."),
                    Rest_parameter_0_implicitly_has_an_any_type: diag(7019, ts.DiagnosticCategory.Error, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."),
                    Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7020, ts.DiagnosticCategory.Error, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."),
                    _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, ts.DiagnosticCategory.Error, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."),
                    _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, ts.DiagnosticCategory.Error, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."),
                    Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, ts.DiagnosticCategory.Error, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."),
                    Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: diag(7025, ts.DiagnosticCategory.Error, "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type."),
                    JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."),
                    Unreachable_code_detected: diag(7027, ts.DiagnosticCategory.Error, "Unreachable_code_detected_7027", "Unreachable code detected.", /*reportsUnnecessary*/ true),
                    Unused_label: diag(7028, ts.DiagnosticCategory.Error, "Unused_label_7028", "Unused label.", /*reportsUnnecessary*/ true),
                    Fallthrough_case_in_switch: diag(7029, ts.DiagnosticCategory.Error, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."),
                    Not_all_code_paths_return_a_value: diag(7030, ts.DiagnosticCategory.Error, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."),
                    Binding_element_0_implicitly_has_an_1_type: diag(7031, ts.DiagnosticCategory.Error, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."),
                    Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."),
                    Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."),
                    Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."),
                    Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts.DiagnosticCategory.Error, "Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_mod_7035", "Try `npm install @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"),
                    Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, ts.DiagnosticCategory.Error, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."),
                    Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, ts.DiagnosticCategory.Message, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."),
                    Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, ts.DiagnosticCategory.Message, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."),
                    Mapped_object_type_implicitly_has_an_any_template_type: diag(7039, ts.DiagnosticCategory.Error, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."),
                    If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: diag(7040, ts.DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}`"),
                    The_containing_arrow_function_captures_the_global_value_of_this: diag(7041, ts.DiagnosticCategory.Error, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."),
                    Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: diag(7042, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."),
                    Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7043, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
                    Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7044, ts.DiagnosticCategory.Suggestion, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
                    Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7045, ts.DiagnosticCategory.Suggestion, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
                    Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: diag(7046, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."),
                    Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: diag(7047, ts.DiagnosticCategory.Suggestion, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."),
                    Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: diag(7048, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."),
                    Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: diag(7049, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."),
                    _0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: diag(7050, ts.DiagnosticCategory.Suggestion, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."),
                    Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: diag(7051, ts.DiagnosticCategory.Error, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"),
                    You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
                    You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
                    import_can_only_be_used_in_a_ts_file: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_a_ts_file_8002", "'import ... =' can only be used in a .ts file."),
                    export_can_only_be_used_in_a_ts_file: diag(8003, ts.DiagnosticCategory.Error, "export_can_only_be_used_in_a_ts_file_8003", "'export=' can only be used in a .ts file."),
                    type_parameter_declarations_can_only_be_used_in_a_ts_file: diag(8004, ts.DiagnosticCategory.Error, "type_parameter_declarations_can_only_be_used_in_a_ts_file_8004", "'type parameter declarations' can only be used in a .ts file."),
                    implements_clauses_can_only_be_used_in_a_ts_file: diag(8005, ts.DiagnosticCategory.Error, "implements_clauses_can_only_be_used_in_a_ts_file_8005", "'implements clauses' can only be used in a .ts file."),
                    interface_declarations_can_only_be_used_in_a_ts_file: diag(8006, ts.DiagnosticCategory.Error, "interface_declarations_can_only_be_used_in_a_ts_file_8006", "'interface declarations' can only be used in a .ts file."),
                    module_declarations_can_only_be_used_in_a_ts_file: diag(8007, ts.DiagnosticCategory.Error, "module_declarations_can_only_be_used_in_a_ts_file_8007", "'module declarations' can only be used in a .ts file."),
                    type_aliases_can_only_be_used_in_a_ts_file: diag(8008, ts.DiagnosticCategory.Error, "type_aliases_can_only_be_used_in_a_ts_file_8008", "'type aliases' can only be used in a .ts file."),
                    _0_can_only_be_used_in_a_ts_file: diag(8009, ts.DiagnosticCategory.Error, "_0_can_only_be_used_in_a_ts_file_8009", "'{0}' can only be used in a .ts file."),
                    types_can_only_be_used_in_a_ts_file: diag(8010, ts.DiagnosticCategory.Error, "types_can_only_be_used_in_a_ts_file_8010", "'types' can only be used in a .ts file."),
                    type_arguments_can_only_be_used_in_a_ts_file: diag(8011, ts.DiagnosticCategory.Error, "type_arguments_can_only_be_used_in_a_ts_file_8011", "'type arguments' can only be used in a .ts file."),
                    parameter_modifiers_can_only_be_used_in_a_ts_file: diag(8012, ts.DiagnosticCategory.Error, "parameter_modifiers_can_only_be_used_in_a_ts_file_8012", "'parameter modifiers' can only be used in a .ts file."),
                    non_null_assertions_can_only_be_used_in_a_ts_file: diag(8013, ts.DiagnosticCategory.Error, "non_null_assertions_can_only_be_used_in_a_ts_file_8013", "'non-null assertions' can only be used in a .ts file."),
                    enum_declarations_can_only_be_used_in_a_ts_file: diag(8015, ts.DiagnosticCategory.Error, "enum_declarations_can_only_be_used_in_a_ts_file_8015", "'enum declarations' can only be used in a .ts file."),
                    type_assertion_expressions_can_only_be_used_in_a_ts_file: diag(8016, ts.DiagnosticCategory.Error, "type_assertion_expressions_can_only_be_used_in_a_ts_file_8016", "'type assertion expressions' can only be used in a .ts file."),
                    Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, ts.DiagnosticCategory.Error, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."),
                    Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."),
                    Report_errors_in_js_files: diag(8019, ts.DiagnosticCategory.Message, "Report_errors_in_js_files_8019", "Report errors in .js files."),
                    JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, ts.DiagnosticCategory.Error, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."),
                    JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, ts.DiagnosticCategory.Error, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."),
                    JSDoc_0_is_not_attached_to_a_class: diag(8022, ts.DiagnosticCategory.Error, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."),
                    JSDoc_0_1_does_not_match_the_extends_2_clause: diag(8023, ts.DiagnosticCategory.Error, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."),
                    JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: diag(8024, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."),
                    Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: diag(8025, ts.DiagnosticCategory.Error, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one `@augments` or `@extends` tag."),
                    Expected_0_type_arguments_provide_these_with_an_extends_tag: diag(8026, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."),
                    Expected_0_1_type_arguments_provide_these_with_an_extends_tag: diag(8027, ts.DiagnosticCategory.Error, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."),
                    JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: diag(8028, ts.DiagnosticCategory.Error, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."),
                    JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: diag(8029, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."),
                    The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, ts.DiagnosticCategory.Error, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."),
                    You_cannot_rename_a_module_via_a_global_import: diag(8031, ts.DiagnosticCategory.Error, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."),
                    Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."),
                    Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clause: diag(9002, ts.DiagnosticCategory.Error, "Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_clas_9002", "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause."),
                    class_expressions_are_not_currently_supported: diag(9003, ts.DiagnosticCategory.Error, "class_expressions_are_not_currently_supported_9003", "'class' expressions are not currently supported."),
                    Language_service_is_disabled: diag(9004, ts.DiagnosticCategory.Error, "Language_service_is_disabled_9004", "Language service is disabled."),
                    JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts.DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
                    JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, ts.DiagnosticCategory.Error, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."),
                    Expected_corresponding_JSX_closing_tag_for_0: diag(17002, ts.DiagnosticCategory.Error, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."),
                    JSX_attribute_expected: diag(17003, ts.DiagnosticCategory.Error, "JSX_attribute_expected_17003", "JSX attribute expected."),
                    Cannot_use_JSX_unless_the_jsx_flag_is_provided: diag(17004, ts.DiagnosticCategory.Error, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."),
                    A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: diag(17005, ts.DiagnosticCategory.Error, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."),
                    An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17006, ts.DiagnosticCategory.Error, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."),
                    A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17007, ts.DiagnosticCategory.Error, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."),
                    JSX_element_0_has_no_corresponding_closing_tag: diag(17008, ts.DiagnosticCategory.Error, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."),
                    super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: diag(17009, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."),
                    Unknown_type_acquisition_option_0: diag(17010, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."),
                    super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: diag(17011, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."),
                    _0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: diag(17012, ts.DiagnosticCategory.Error, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"),
                    Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, ts.DiagnosticCategory.Error, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."),
                    JSX_fragment_has_no_corresponding_closing_tag: diag(17014, ts.DiagnosticCategory.Error, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."),
                    Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, ts.DiagnosticCategory.Error, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."),
                    JSX_fragment_is_not_supported_when_using_jsxFactory: diag(17016, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_jsxFactory_17016", "JSX fragment is not supported when using --jsxFactory"),
                    JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma: diag(17017, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma_17017", "JSX fragment is not supported when using an inline JSX factory pragma"),
                    Circularity_detected_while_resolving_configuration_Colon_0: diag(18000, ts.DiagnosticCategory.Error, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"),
                    A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not: diag(18001, ts.DiagnosticCategory.Error, "A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not_18001", "A path in an 'extends' option must be relative or rooted, but '{0}' is not."),
                    The_files_list_in_config_file_0_is_empty: diag(18002, ts.DiagnosticCategory.Error, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."),
                    No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: diag(18003, ts.DiagnosticCategory.Error, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."),
                    File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module: diag(80001, ts.DiagnosticCategory.Suggestion, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module_80001", "File is a CommonJS module; it may be converted to an ES6 module."),
                    This_constructor_function_may_be_converted_to_a_class_declaration: diag(80002, ts.DiagnosticCategory.Suggestion, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."),
                    Import_may_be_converted_to_a_default_import: diag(80003, ts.DiagnosticCategory.Suggestion, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."),
                    JSDoc_types_may_be_moved_to_TypeScript_types: diag(80004, ts.DiagnosticCategory.Suggestion, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."),
                    require_call_may_be_converted_to_an_import: diag(80005, ts.DiagnosticCategory.Suggestion, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."),
                    This_may_be_converted_to_an_async_function: diag(80006, ts.DiagnosticCategory.Suggestion, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."),
                    Add_missing_super_call: diag(90001, ts.DiagnosticCategory.Message, "Add_missing_super_call_90001", "Add missing 'super()' call"),
                    Make_super_call_the_first_statement_in_the_constructor: diag(90002, ts.DiagnosticCategory.Message, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"),
                    Change_extends_to_implements: diag(90003, ts.DiagnosticCategory.Message, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
                    Remove_declaration_for_Colon_0: diag(90004, ts.DiagnosticCategory.Message, "Remove_declaration_for_Colon_0_90004", "Remove declaration for: '{0}'"),
                    Remove_import_from_0: diag(90005, ts.DiagnosticCategory.Message, "Remove_import_from_0_90005", "Remove import from '{0}'"),
                    Implement_interface_0: diag(90006, ts.DiagnosticCategory.Message, "Implement_interface_0_90006", "Implement interface '{0}'"),
                    Implement_inherited_abstract_class: diag(90007, ts.DiagnosticCategory.Message, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"),
                    Add_0_to_unresolved_variable: diag(90008, ts.DiagnosticCategory.Message, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"),
                    Remove_destructuring: diag(90009, ts.DiagnosticCategory.Message, "Remove_destructuring_90009", "Remove destructuring"),
                    Remove_variable_statement: diag(90010, ts.DiagnosticCategory.Message, "Remove_variable_statement_90010", "Remove variable statement"),
                    Remove_template_tag: diag(90011, ts.DiagnosticCategory.Message, "Remove_template_tag_90011", "Remove template tag"),
                    Remove_type_parameters: diag(90012, ts.DiagnosticCategory.Message, "Remove_type_parameters_90012", "Remove type parameters"),
                    Import_0_from_module_1: diag(90013, ts.DiagnosticCategory.Message, "Import_0_from_module_1_90013", "Import '{0}' from module \"{1}\""),
                    Change_0_to_1: diag(90014, ts.DiagnosticCategory.Message, "Change_0_to_1_90014", "Change '{0}' to '{1}'"),
                    Add_0_to_existing_import_declaration_from_1: diag(90015, ts.DiagnosticCategory.Message, "Add_0_to_existing_import_declaration_from_1_90015", "Add '{0}' to existing import declaration from \"{1}\""),
                    Declare_property_0: diag(90016, ts.DiagnosticCategory.Message, "Declare_property_0_90016", "Declare property '{0}'"),
                    Add_index_signature_for_property_0: diag(90017, ts.DiagnosticCategory.Message, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"),
                    Disable_checking_for_this_file: diag(90018, ts.DiagnosticCategory.Message, "Disable_checking_for_this_file_90018", "Disable checking for this file"),
                    Ignore_this_error_message: diag(90019, ts.DiagnosticCategory.Message, "Ignore_this_error_message_90019", "Ignore this error message"),
                    Initialize_property_0_in_the_constructor: diag(90020, ts.DiagnosticCategory.Message, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"),
                    Initialize_static_property_0: diag(90021, ts.DiagnosticCategory.Message, "Initialize_static_property_0_90021", "Initialize static property '{0}'"),
                    Change_spelling_to_0: diag(90022, ts.DiagnosticCategory.Message, "Change_spelling_to_0_90022", "Change spelling to '{0}'"),
                    Declare_method_0: diag(90023, ts.DiagnosticCategory.Message, "Declare_method_0_90023", "Declare method '{0}'"),
                    Declare_static_method_0: diag(90024, ts.DiagnosticCategory.Message, "Declare_static_method_0_90024", "Declare static method '{0}'"),
                    Prefix_0_with_an_underscore: diag(90025, ts.DiagnosticCategory.Message, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"),
                    Rewrite_as_the_indexed_access_type_0: diag(90026, ts.DiagnosticCategory.Message, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"),
                    Declare_static_property_0: diag(90027, ts.DiagnosticCategory.Message, "Declare_static_property_0_90027", "Declare static property '{0}'"),
                    Call_decorator_expression: diag(90028, ts.DiagnosticCategory.Message, "Call_decorator_expression_90028", "Call decorator expression"),
                    Add_async_modifier_to_containing_function: diag(90029, ts.DiagnosticCategory.Message, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"),
                    Replace_infer_0_with_unknown: diag(90030, ts.DiagnosticCategory.Message, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"),
                    Replace_all_unused_infer_with_unknown: diag(90031, ts.DiagnosticCategory.Message, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"),
                    Import_default_0_from_module_1: diag(90032, ts.DiagnosticCategory.Message, "Import_default_0_from_module_1_90032", "Import default '{0}' from module \"{1}\""),
                    Add_default_import_0_to_existing_import_declaration_from_1: diag(90033, ts.DiagnosticCategory.Message, "Add_default_import_0_to_existing_import_declaration_from_1_90033", "Add default import '{0}' to existing import declaration from \"{1}\""),
                    Add_parameter_name: diag(90034, ts.DiagnosticCategory.Message, "Add_parameter_name_90034", "Add parameter name"),
                    Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
                    Convert_function_0_to_class: diag(95002, ts.DiagnosticCategory.Message, "Convert_function_0_to_class_95002", "Convert function '{0}' to class"),
                    Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
                    Extract_function: diag(95005, ts.DiagnosticCategory.Message, "Extract_function_95005", "Extract function"),
                    Extract_constant: diag(95006, ts.DiagnosticCategory.Message, "Extract_constant_95006", "Extract constant"),
                    Extract_to_0_in_enclosing_scope: diag(95007, ts.DiagnosticCategory.Message, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"),
                    Extract_to_0_in_1_scope: diag(95008, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"),
                    Annotate_with_type_from_JSDoc: diag(95009, ts.DiagnosticCategory.Message, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"),
                    Annotate_with_types_from_JSDoc: diag(95010, ts.DiagnosticCategory.Message, "Annotate_with_types_from_JSDoc_95010", "Annotate with types from JSDoc"),
                    Infer_type_of_0_from_usage: diag(95011, ts.DiagnosticCategory.Message, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"),
                    Infer_parameter_types_from_usage: diag(95012, ts.DiagnosticCategory.Message, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"),
                    Convert_to_default_import: diag(95013, ts.DiagnosticCategory.Message, "Convert_to_default_import_95013", "Convert to default import"),
                    Install_0: diag(95014, ts.DiagnosticCategory.Message, "Install_0_95014", "Install '{0}'"),
                    Replace_import_with_0: diag(95015, ts.DiagnosticCategory.Message, "Replace_import_with_0_95015", "Replace import with '{0}'."),
                    Use_synthetic_default_member: diag(95016, ts.DiagnosticCategory.Message, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."),
                    Convert_to_ES6_module: diag(95017, ts.DiagnosticCategory.Message, "Convert_to_ES6_module_95017", "Convert to ES6 module"),
                    Add_undefined_type_to_property_0: diag(95018, ts.DiagnosticCategory.Message, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"),
                    Add_initializer_to_property_0: diag(95019, ts.DiagnosticCategory.Message, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"),
                    Add_definite_assignment_assertion_to_property_0: diag(95020, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"),
                    Add_all_missing_members: diag(95022, ts.DiagnosticCategory.Message, "Add_all_missing_members_95022", "Add all missing members"),
                    Infer_all_types_from_usage: diag(95023, ts.DiagnosticCategory.Message, "Infer_all_types_from_usage_95023", "Infer all types from usage"),
                    Delete_all_unused_declarations: diag(95024, ts.DiagnosticCategory.Message, "Delete_all_unused_declarations_95024", "Delete all unused declarations"),
                    Prefix_all_unused_declarations_with_where_possible: diag(95025, ts.DiagnosticCategory.Message, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"),
                    Fix_all_detected_spelling_errors: diag(95026, ts.DiagnosticCategory.Message, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"),
                    Add_initializers_to_all_uninitialized_properties: diag(95027, ts.DiagnosticCategory.Message, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"),
                    Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"),
                    Add_undefined_type_to_all_uninitialized_properties: diag(95029, ts.DiagnosticCategory.Message, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"),
                    Change_all_jsdoc_style_types_to_TypeScript: diag(95030, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"),
                    Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: diag(95031, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"),
                    Implement_all_unimplemented_interfaces: diag(95032, ts.DiagnosticCategory.Message, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"),
                    Install_all_missing_types_packages: diag(95033, ts.DiagnosticCategory.Message, "Install_all_missing_types_packages_95033", "Install all missing types packages"),
                    Rewrite_all_as_indexed_access_types: diag(95034, ts.DiagnosticCategory.Message, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"),
                    Convert_all_to_default_imports: diag(95035, ts.DiagnosticCategory.Message, "Convert_all_to_default_imports_95035", "Convert all to default imports"),
                    Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, ts.DiagnosticCategory.Message, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"),
                    Add_qualifier_to_all_unresolved_variables_matching_a_member_name: diag(95037, ts.DiagnosticCategory.Message, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"),
                    Change_all_extended_interfaces_to_implements: diag(95038, ts.DiagnosticCategory.Message, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"),
                    Add_all_missing_super_calls: diag(95039, ts.DiagnosticCategory.Message, "Add_all_missing_super_calls_95039", "Add all missing super calls"),
                    Implement_all_inherited_abstract_classes: diag(95040, ts.DiagnosticCategory.Message, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"),
                    Add_all_missing_async_modifiers: diag(95041, ts.DiagnosticCategory.Message, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"),
                    Add_ts_ignore_to_all_error_messages: diag(95042, ts.DiagnosticCategory.Message, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"),
                    Annotate_everything_with_types_from_JSDoc: diag(95043, ts.DiagnosticCategory.Message, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"),
                    Add_to_all_uncalled_decorators: diag(95044, ts.DiagnosticCategory.Message, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"),
                    Convert_all_constructor_functions_to_classes: diag(95045, ts.DiagnosticCategory.Message, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"),
                    Generate_get_and_set_accessors: diag(95046, ts.DiagnosticCategory.Message, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"),
                    Convert_require_to_import: diag(95047, ts.DiagnosticCategory.Message, "Convert_require_to_import_95047", "Convert 'require' to 'import'"),
                    Convert_all_require_to_import: diag(95048, ts.DiagnosticCategory.Message, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"),
                    Move_to_a_new_file: diag(95049, ts.DiagnosticCategory.Message, "Move_to_a_new_file_95049", "Move to a new file"),
                    Remove_unreachable_code: diag(95050, ts.DiagnosticCategory.Message, "Remove_unreachable_code_95050", "Remove unreachable code"),
                    Remove_all_unreachable_code: diag(95051, ts.DiagnosticCategory.Message, "Remove_all_unreachable_code_95051", "Remove all unreachable code"),
                    Add_missing_typeof: diag(95052, ts.DiagnosticCategory.Message, "Add_missing_typeof_95052", "Add missing 'typeof'"),
                    Remove_unused_label: diag(95053, ts.DiagnosticCategory.Message, "Remove_unused_label_95053", "Remove unused label"),
                    Remove_all_unused_labels: diag(95054, ts.DiagnosticCategory.Message, "Remove_all_unused_labels_95054", "Remove all unused labels"),
                    Convert_0_to_mapped_object_type: diag(95055, ts.DiagnosticCategory.Message, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"),
                    Convert_namespace_import_to_named_imports: diag(95056, ts.DiagnosticCategory.Message, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"),
                    Convert_named_imports_to_namespace_import: diag(95057, ts.DiagnosticCategory.Message, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"),
                    Add_or_remove_braces_in_an_arrow_function: diag(95058, ts.DiagnosticCategory.Message, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"),
                    Add_braces_to_arrow_function: diag(95059, ts.DiagnosticCategory.Message, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"),
                    Remove_braces_from_arrow_function: diag(95060, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"),
                    Convert_default_export_to_named_export: diag(95061, ts.DiagnosticCategory.Message, "Convert_default_export_to_named_export_95061", "Convert default export to named export"),
                    Convert_named_export_to_default_export: diag(95062, ts.DiagnosticCategory.Message, "Convert_named_export_to_default_export_95062", "Convert named export to default export"),
                    Add_missing_enum_member_0: diag(95063, ts.DiagnosticCategory.Message, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"),
                    Add_all_missing_imports: diag(95064, ts.DiagnosticCategory.Message, "Add_all_missing_imports_95064", "Add all missing imports"),
                    Convert_to_async_function: diag(95065, ts.DiagnosticCategory.Message, "Convert_to_async_function_95065", "Convert to async function"),
                    Convert_all_to_async_functions: diag(95066, ts.DiagnosticCategory.Message, "Convert_all_to_async_functions_95066", "Convert all to async functions"),
                    Generate_types_for_0: diag(95067, ts.DiagnosticCategory.Message, "Generate_types_for_0_95067", "Generate types for '{0}'"),
                    Generate_types_for_all_packages_without_types: diag(95068, ts.DiagnosticCategory.Message, "Generate_types_for_all_packages_without_types_95068", "Generate types for all packages without types"),
                    Add_unknown_conversion_for_non_overlapping_types: diag(95069, ts.DiagnosticCategory.Message, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"),
                    Add_unknown_to_all_conversions_of_non_overlapping_types: diag(95070, ts.DiagnosticCategory.Message, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"),
                    Add_missing_new_operator_to_call: diag(95071, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"),
                    Add_missing_new_operator_to_all_calls: diag(95072, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"),
                    Add_names_to_all_parameters_without_names: diag(95073, ts.DiagnosticCategory.Message, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"),
                    Enable_the_experimentalDecorators_option_in_your_configuration_file: diag(95074, ts.DiagnosticCategory.Message, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"),
                    Convert_parameters_to_destructured_object: diag(95075, ts.DiagnosticCategory.Message, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"),
                };
            })(ts || (ts = {}));
            var ts;
            (function (ts) {
                var _a;
                /* @internal */
                function tokenIsIdentifierOrKeyword(token) {
                    return token >= 72 /* Identifier */;
                }
                ts.tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword;
                /* @internal */
                function tokenIsIdentifierOrKeywordOrGreaterThan(token) {
                    return token === 30 /* GreaterThanToken */ || tokenIsIdentifierOrKeyword(token);
                }
                ts.tokenIsIdentifierOrKeywordOrGreaterThan = tokenIsIdentifierOrKeywordOrGreaterThan;
                var textToKeywordObj = (_a = {
                        abstract: 118 /* AbstractKeyword */,
                        any: 120 /* AnyKeyword */,
                        as: 119 /* AsKeyword */,
                        bigint: 146 /* BigIntKeyword */,
                        boolean: 123 /* BooleanKeyword */,
                        break: 73 /* BreakKeyword */,
                        case: 74 /* CaseKeyword */,
                        catch: 75 /* CatchKeyword */,
                        class: 76 /* ClassKeyword */,
                        continue: 78 /* ContinueKeyword */,
                        const: 77 /* ConstKeyword */
                    },
                    _a["" + "constructor"] = 124 /* ConstructorKeyword */,
                    _a.debugger = 79 /* DebuggerKeyword */,
                    _a.declare = 125 /* DeclareKeyword */,
                    _a.default = 80 /* DefaultKeyword */,
                    _a.delete = 81 /* DeleteKeyword */,
                    _a.do = 82 /* DoKeyword */,
                    _a.else = 83 /* ElseKeyword */,
                    _a.enum = 84 /* EnumKeyword */,
                    _a.export = 85 /* ExportKeyword */,
                    _a.extends = 86 /* ExtendsKeyword */,
                    _a.false = 87 /* FalseKeyword */,
                    _a.finally = 88 /* FinallyKeyword */,
                    _a.for = 89 /* ForKeyword */,
                    _a.from = 144 /* FromKeyword */,
                    _a.function = 90 /* FunctionKeyword */,
                    _a.get = 126 /* GetKeyword */,
                    _a.if = 91 /* IfKeyword */,
                    _a.implements = 109 /* ImplementsKeyword */,
                    _a.import = 92 /* ImportKeyword */,
                    _a.in = 93 /* InKeyword */,
                    _a.infer = 127 /* InferKeyword */,
                    _a.instanceof = 94 /* InstanceOfKeyword */,
                    _a.interface = 110 /* InterfaceKeyword */,
                    _a.is = 128 /* IsKeyword */,
                    _a.keyof = 129 /* KeyOfKeyword */,
                    _a.let = 111 /* LetKeyword */,
                    _a.module = 130 /* ModuleKeyword */,
                    _a.namespace = 131 /* NamespaceKeyword */,
                    _a.never = 132 /* NeverKeyword */,
                    _a.new = 95 /* NewKeyword */,
                    _a.null = 96 /* NullKeyword */,
                    _a.number = 135 /* NumberKeyword */,
                    _a.object = 136 /* ObjectKeyword */,
                    _a.package = 112 /* PackageKeyword */,
                    _a.private = 113 /* PrivateKeyword */,
                    _a.protected = 114 /* ProtectedKeyword */,
                    _a.public = 115 /* PublicKeyword */,
                    _a.readonly = 133 /* ReadonlyKeyword */,
                    _a.require = 134 /* RequireKeyword */,
                    _a.global = 145 /* GlobalKeyword */,
                    _a.return = 97 /* ReturnKeyword */,
                    _a.set = 137 /* SetKeyword */,
                    _a.static = 116 /* StaticKeyword */,
                    _a.string = 138 /* StringKeyword */,
                    _a.super = 98 /* SuperKeyword */,
                    _a.switch = 99 /* SwitchKeyword */,
                    _a.symbol = 139 /* SymbolKeyword */,
                    _a.this = 100 /* ThisKeyword */,
                    _a.throw = 101 /* ThrowKeyword */,
                    _a.true = 102 /* TrueKeyword */,
                    _a.try = 103 /* TryKeyword */,
                    _a.type = 140 /* TypeKeyword */,
                    _a.typeof = 104 /* TypeOfKeyword */,
                    _a.undefined = 141 /* UndefinedKeyword */,
                    _a.unique = 142 /* UniqueKeyword */,
                    _a.unknown = 143 /* UnknownKeyword */,
                    _a.var = 105 /* VarKeyword */,
                    _a.void = 106 /* VoidKeyword */,
                    _a.while = 107 /* WhileKeyword */,
                    _a.with = 108 /* WithKeyword */,
                    _a.yield = 117 /* YieldKeyword */,
                    _a.async = 121 /* AsyncKeyword */,
                    _a.await = 122 /* AwaitKeyword */,
                    _a.of = 147 /* OfKeyword */,
                    _a);
                var textToKeyword = ts.createMapFromTemplate(textToKeywordObj);
                var textToToken = ts.createMapFromTemplate(__assign({}, textToKeywordObj, { "{": 18 /* OpenBraceToken */, "}": 19 /* CloseBraceToken */, "(": 20 /* OpenParenToken */, ")": 21 /* CloseParenToken */, "[": 22 /* OpenBracketToken */, "]": 23 /* CloseBracketToken */, ".": 24 /* DotToken */, "...": 25 /* DotDotDotToken */, ";": 26 /* SemicolonToken */, ",": 27 /* CommaToken */, "<": 28 /* LessThanToken */, ">": 30 /* GreaterThanToken */, "<=": 31 /* LessThanEqualsToken */, ">=": 32 /* GreaterThanEqualsToken */, "==": 33 /* EqualsEqualsToken */, "!=": 34 /* ExclamationEqualsToken */, "===": 35 /* EqualsEqualsEqualsToken */, "!==": 36 /* ExclamationEqualsEqualsToken */, "=>": 37 /* EqualsGreaterThanToken */, "+": 38 /* PlusToken */, "-": 39 /* MinusToken */, "**": 41 /* AsteriskAsteriskToken */, "*": 40 /* AsteriskToken */, "/": 42 /* SlashToken */, "%": 43 /* PercentToken */, "++": 44 /* PlusPlusToken */, "--": 45 /* MinusMinusToken */, "<<": 46 /* LessThanLessThanToken */, "</": 29 /* LessThanSlashToken */, ">>": 47 /* GreaterThanGreaterThanToken */, ">>>": 48 /* GreaterThanGreaterThanGreaterThanToken */, "&": 49 /* AmpersandToken */, "|": 50 /* BarToken */, "^": 51 /* CaretToken */, "!": 52 /* ExclamationToken */, "~": 53 /* TildeToken */, "&&": 54 /* AmpersandAmpersandToken */, "||": 55 /* BarBarToken */, "?": 56 /* QuestionToken */, ":": 57 /* ColonToken */, "=": 59 /* EqualsToken */, "+=": 60 /* PlusEqualsToken */, "-=": 61 /* MinusEqualsToken */, "*=": 62 /* AsteriskEqualsToken */, "**=": 63 /* AsteriskAsteriskEqualsToken */, "/=": 64 /* SlashEqualsToken */, "%=": 65 /* PercentEqualsToken */, "<<=": 66 /* LessThanLessThanEqualsToken */, ">>=": 67 /* GreaterThanGreaterThanEqualsToken */, ">>>=": 68 /* GreaterThanGreaterThanGreaterThanEqualsToken */, "&=": 69 /* AmpersandEqualsToken */, "|=": 70 /* BarEqualsToken */, "^=": 71 /* CaretEqualsToken */, "@": 58 /* AtToken */ }));
                /*
                    As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers
                    IdentifierStart ::
                        Can contain Unicode 3.0.0 categories:
                        Uppercase letter (Lu),
                        Lowercase letter (Ll),
                        Titlecase letter (Lt),
                        Modifier letter (Lm),
                        Other letter (Lo), or
                        Letter number (Nl).
                    IdentifierPart :: =
                        Can contain IdentifierStart + Unicode 3.0.0 categories:
                        Non-spacing mark (Mn),
                        Combining spacing mark (Mc),
                        Decimal number (Nd), or
                        Connector punctuation (Pc).

                    Codepoint ranges for ES3 Identifiers are extracted from the Unicode 3.0.0 specification at:
                    http://www.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.txt
                */
                var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
                var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
                /*
                    As per ECMAScript Language Specification 5th Edition, Section 7.6: ISyntaxToken Names and Identifiers
                    IdentifierStart ::
                        Can contain Unicode 6.2 categories:
                        Uppercase letter (Lu),
                        Lowercase letter (Ll),
                        Titlecase letter (Lt),
                        Modifier letter (Lm),
                        Other letter (Lo), or
                        Letter number (Nl).
                    IdentifierPart ::
                        Can contain IdentifierStart + Unicode 6.2 categories:
                        Non-spacing mark (Mn),
                        Combining spacing mark (Mc),
                        Decimal number (Nd),
                        Connector punctuation (Pc),
                        <ZWNJ>, or
                        <ZWJ>.

                    Codepoint ranges for ES5 Identifiers are extracted from the Unicode 6.2 specification at:
                    http://www.unicode.org/Public/6.2.0/ucd/UnicodeData.txt
                */
                var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
                var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
                function lookupInUnicodeMap(code, map) {
                    // Bail out quickly if it couldn't possibly be in the map.
                    if (code < map[0]) {
                        return false;
                    }
                    // Perform binary search in one of the Unicode range maps
                    var lo = 0;
                    var hi = map.length;
                    var mid;
                    while (lo + 1 < hi) {
                        mid = lo + (hi - lo) / 2;
                        // mid has to be even to catch a range's beginning
                        mid -= mid % 2;
                        if (map[mid] <= code && code <= map[mid + 1]) {
                            return true;
                        }
                        if (code < map[mid]) {
                            hi = mid;
                        }
                        else {
                            lo = mid + 2;
                        }
                    }
                    return false;
                }
                /* @internal */ function isUnicodeIdentifierStart(code, languageVersion) {
                    return languageVersion >= 1 /* ES5 */ ?
                        lookupInUnicodeMap(code, unicodeES5IdentifierStart) :
                        lookupInUnicodeMap(code, unicodeES3IdentifierStart);
                }
                ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart;
                function isUnicodeIdentifierPart(code, languageVersion) {
                    return languageVersion >= 1 /* ES5 */ ?
                        lookupInUnicodeMap(code, unicodeES5IdentifierPart) :
                        lookupInUnicodeMap(code, unicodeES3IdentifierPart);
                }
                function makeReverseMap(source) {
                    var result = [];
                    source.forEach(function (value, name) {
                        result[value] = name;
                    });
                    return result;
                }
                var tokenStrings = makeReverseMap(textToToken);
                function tokenToString(t) {
                    return tokenStrings[t];
                }
                ts.tokenToString = tokenToString;
                /* @internal */
                function stringToToken(s) {
                    return textToToken.get(s);
                }
                ts.stringToToken = stringToToken;
                /* @internal */
                function computeLineStarts(text) {
                    var result = new Array();
                    var pos = 0;
                    var lineStart = 0;
                    while (pos < text.length) {
                        var ch = text.charCodeAt(pos);
                        pos++;
                        switch (ch) {
                            case 13 /* carriageReturn */:
                                if (text.charCodeAt(pos) === 10 /* lineFeed */) {
                                    pos++;
                                }
                            // falls through
                            case 10 /* lineFeed */:
                                result.push(lineStart);
                                lineStart = pos;
                                break;
                            default:
                                if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
                                    result.push(lineStart);
                                    lineStart = pos;
                                }
                                break;
                        }
                    }
                    result.push(lineStart);
                    return result;
                }
                ts.computeLineStarts = computeLineStarts;
                function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) {
                    return sourceFile.getPositionOfLineAndCharacter ?
                        sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) :
                        computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits);
                }
                ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter;
                /* @internal */
                function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) {
                    if (line < 0 || line >= lineStarts.length) {
                        if (allowEdits) {
                            // Clamp line to nearest allowable value
                            line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line;
                        }
                        else {
                            ts.Debug.fail("Bad line number. Line: " + line + ", lineStarts.length: " + lineStarts.length + " , line map is correct? " + (debugText !== undefined ? ts.arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown"));
                        }
                    }
                    var res = lineStarts[line] + character;
                    if (allowEdits) {
                        // Clamp to nearest allowable values to allow the underlying to be edited without crashing (accuracy is lost, instead)
                        // TODO: Somehow track edits between file as it was during the creation of sourcemap we have and the current file and
                        // apply them to the computed position to improve accuracy
                        return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res;
                    }
                    if (line < lineStarts.length - 1) {
                        ts.Debug.assert(res < lineStarts[line + 1]);
                    }
                    else if (debugText !== undefined) {
                        ts.Debug.assert(res <= debugText.length); // Allow single character overflow for trailing newline
                    }
                    return res;
                }
                ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter;
                /* @internal */
                function getLineStarts(sourceFile) {
                    return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text));
                }
                ts.getLineStarts = getLineStarts;
                /* @internal */
                /**
                 * We assume the first line starts at position 0 and 'position' is non-negative.
                 */
                function computeLineAndCharacterOfPosition(lineStarts, position) {
                    var lineNumber = ts.binarySearch(lineStarts, position, ts.identity, ts.compareValues);
                    if (lineNumber < 0) {
                        // If the actual position was not found,
                        // the binary search returns the 2's-complement of the next line start
                        // e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20
                        // then the search will return -2.
                        //
                        // We want the index of the previous line start, so we subtract 1.
                        // Review 2's-complement if this is confusing.
                        lineNumber = ~lineNumber - 1;
                        ts.Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file");
                    }
                    return {
                        line: lineNumber,
                        character: position - lineStarts[lineNumber]
                    };
                }
                ts.computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition;
                function getLineAndCharacterOfPosition(sourceFile, position) {
                    return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
                }
                ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition;
                function isWhiteSpaceLike(ch) {
                    return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
                }
                ts.isWhiteSpaceLike = isWhiteSpaceLike;
                /** Does not include line breaks. For that, see isWhiteSpaceLike. */
                function isWhiteSpaceSingleLine(ch) {
                    // Note: nextLine is in the Zs space, and should be considered to be a whitespace.
                    // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
                    return ch === 32 /* space */ ||
                        ch === 9 /* tab */ ||
                        ch === 11 /* verticalTab */ ||